@elizaos/core 1.7.1-alpha.9 → 1.7.1-beta.0

package/dist/node/index.node.js

@@ -5053,11 +5053,11 @@ var require_ast = __commonJS((exports, module) => {
       helperExpression: function helperExpression(node) {
         return node.type === "SubExpression" || (node.type === "MustacheStatement" || node.type === "BlockStatement") && !!(node.params && node.params.length || node.hash);
       },
-      scopedId: function scopedId(path) {
-        return /^\.|this\b/.test(path.original);
+      scopedId: function scopedId(path2) {
+        return /^\.|this\b/.test(path2.original);
       },
-      simpleId: function simpleId(path) {
-        return path.parts.length === 1 && !AST.helpers.scopedId(path) && !path.depth;
+      simpleId: function simpleId(path2) {
+        return path2.parts.length === 1 && !AST.helpers.scopedId(path2) && !path2.depth;
       }
     }
   };
@@ -6117,12 +6117,12 @@ var require_helpers2 = __commonJS((exports) => {
       loc
     };
   }
-  function prepareMustache(path, params, hash, open, strip, locInfo) {
+  function prepareMustache(path2, params, hash, open, strip, locInfo) {
     var escapeFlag = open.charAt(3) || open.charAt(2), escaped = escapeFlag !== "{" && escapeFlag !== "&";
     var decorator = /\*/.test(open);
     return {
       type: decorator ? "Decorator" : "MustacheStatement",
-      path,
+      path: path2,
       params,
       hash,
       escaped,
@@ -6386,9 +6386,9 @@ var require_compiler = __commonJS((exports) => {
     },
     DecoratorBlock: function DecoratorBlock(decorator) {
       var program = decorator.program && this.compileProgram(decorator.program);
-      var params = this.setupFullMustacheParams(decorator, program, undefined), path = decorator.path;
+      var params = this.setupFullMustacheParams(decorator, program, undefined), path2 = decorator.path;
       this.useDecorators = true;
-      this.opcode("registerDecorator", params.length, path.original);
+      this.opcode("registerDecorator", params.length, path2.original);
     },
     PartialStatement: function PartialStatement(partial) {
       this.usePartial = true;
@@ -6451,46 +6451,46 @@ var require_compiler = __commonJS((exports) => {
       }
     },
     ambiguousSexpr: function ambiguousSexpr(sexpr, program, inverse) {
-      var path = sexpr.path, name = path.parts[0], isBlock = program != null || inverse != null;
-      this.opcode("getContext", path.depth);
+      var path2 = sexpr.path, name = path2.parts[0], isBlock = program != null || inverse != null;
+      this.opcode("getContext", path2.depth);
       this.opcode("pushProgram", program);
       this.opcode("pushProgram", inverse);
-      path.strict = true;
-      this.accept(path);
+      path2.strict = true;
+      this.accept(path2);
       this.opcode("invokeAmbiguous", name, isBlock);
     },
     simpleSexpr: function simpleSexpr(sexpr) {
-      var path = sexpr.path;
-      path.strict = true;
-      this.accept(path);
+      var path2 = sexpr.path;
+      path2.strict = true;
+      this.accept(path2);
       this.opcode("resolvePossibleLambda");
     },
     helperSexpr: function helperSexpr(sexpr, program, inverse) {
-      var params = this.setupFullMustacheParams(sexpr, program, inverse), path = sexpr.path, name = path.parts[0];
+      var params = this.setupFullMustacheParams(sexpr, program, inverse), path2 = sexpr.path, name = path2.parts[0];
       if (this.options.knownHelpers[name]) {
         this.opcode("invokeKnownHelper", params.length, name);
       } else if (this.options.knownHelpersOnly) {
         throw new _exception2["default"]("You specified knownHelpersOnly, but used the unknown helper " + name, sexpr);
       } else {
-        path.strict = true;
-        path.falsy = true;
-        this.accept(path);
-        this.opcode("invokeHelper", params.length, path.original, _ast2["default"].helpers.simpleId(path));
+        path2.strict = true;
+        path2.falsy = true;
+        this.accept(path2);
+        this.opcode("invokeHelper", params.length, path2.original, _ast2["default"].helpers.simpleId(path2));
       }
     },
-    PathExpression: function PathExpression(path) {
-      this.addDepth(path.depth);
-      this.opcode("getContext", path.depth);
-      var name = path.parts[0], scoped = _ast2["default"].helpers.scopedId(path), blockParamId = !path.depth && !scoped && this.blockParamIndex(name);
+    PathExpression: function PathExpression(path2) {
+      this.addDepth(path2.depth);
+      this.opcode("getContext", path2.depth);
+      var name = path2.parts[0], scoped = _ast2["default"].helpers.scopedId(path2), blockParamId = !path2.depth && !scoped && this.blockParamIndex(name);
       if (blockParamId) {
-        this.opcode("lookupBlockParam", blockParamId, path.parts);
+        this.opcode("lookupBlockParam", blockParamId, path2.parts);
       } else if (!name) {
         this.opcode("pushContext");
-      } else if (path.data) {
+      } else if (path2.data) {
         this.options.data = true;
-        this.opcode("lookupData", path.depth, path.parts, path.strict);
+        this.opcode("lookupData", path2.depth, path2.parts, path2.strict);
       } else {
-        this.opcode("lookupOnContext", path.parts, path.falsy, path.strict, scoped);
+        this.opcode("lookupOnContext", path2.parts, path2.falsy, path2.strict, scoped);
       }
     },
     StringLiteral: function StringLiteral(string) {
@@ -6834,16 +6834,16 @@ var require_util = __commonJS((exports) => {
   }
   exports.urlGenerate = urlGenerate;
   function normalize(aPath) {
-    var path = aPath;
+    var path2 = aPath;
     var url = urlParse(aPath);
     if (url) {
       if (!url.path) {
         return aPath;
       }
-      path = url.path;
+      path2 = url.path;
     }
-    var isAbsolute = exports.isAbsolute(path);
-    var parts = path.split(/\/+/);
+    var isAbsolute = exports.isAbsolute(path2);
+    var parts = path2.split(/\/+/);
     for (var part, up = 0, i = parts.length - 1;i >= 0; i--) {
       part = parts[i];
       if (part === ".") {
@@ -6860,15 +6860,15 @@ var require_util = __commonJS((exports) => {
         }
       }
     }
-    path = parts.join("/");
-    if (path === "") {
-      path = isAbsolute ? "/" : ".";
+    path2 = parts.join("/");
+    if (path2 === "") {
+      path2 = isAbsolute ? "/" : ".";
     }
     if (url) {
-      url.path = path;
+      url.path = path2;
       return urlGenerate(url);
     }
-    return path;
+    return path2;
   }
   exports.normalize = normalize;
   function join(aRoot, aPath) {
@@ -9425,8 +9425,8 @@ var require_printer = __commonJS((exports) => {
     return this.accept(sexpr.path) + " " + params + hash;
   };
   PrintVisitor.prototype.PathExpression = function(id) {
-    var path = id.parts.join("/");
-    return (id.data ? "@" : "") + "PATH:" + path;
+    var path2 = id.parts.join("/");
+    return (id.data ? "@" : "") + "PATH:" + path2;
   };
   PrintVisitor.prototype.StringLiteral = function(string) {
     return '"' + string.value + '"';
@@ -9463,8 +9463,8 @@ var require_lib = __commonJS((exports, module) => {
   handlebars.print = printer.print;
   module.exports = handlebars;
   function extension(module2, filename) {
-    var fs = __require("fs");
-    var templateString = fs.readFileSync(filename, "utf8");
+    var fs2 = __require("fs");
+    var templateString = fs2.readFileSync(filename, "utf8");
     module2.exports = handlebars.compile(templateString);
   }
   if (__require.extensions) {
@@ -9653,19 +9653,19 @@ var require_parse4 = __commonJS((exports, module) => {
     const wildcards = [];
     var wcLen = 0;
     const secret = paths.reduce(function(o, strPath, ix) {
-      var path = strPath.match(rx).map((p) => p.replace(/'|"|`/g, ""));
+      var path2 = strPath.match(rx).map((p) => p.replace(/'|"|`/g, ""));
       const leadingBracket = strPath[0] === "[";
-      path = path.map((p) => {
+      path2 = path2.map((p) => {
         if (p[0] === "[")
           return p.substr(1, p.length - 2);
         else
           return p;
       });
-      const star = path.indexOf("*");
+      const star = path2.indexOf("*");
       if (star > -1) {
-        const before = path.slice(0, star);
+        const before = path2.slice(0, star);
         const beforeStr = before.join(".");
-        const after = path.slice(star + 1, path.length);
+        const after = path2.slice(star + 1, path2.length);
         const nested = after.length > 0;
         wcLen++;
         wildcards.push({
@@ -9676,7 +9676,7 @@ var require_parse4 = __commonJS((exports, module) => {
         });
       } else {
         o[strPath] = {
-          path,
+          path: path2,
           val: undefined,
           precensored: false,
           circle: "",
@@ -9719,13 +9719,13 @@ var require_redactor = __commonJS((exports, module) => {
     return redact;
   }
   function redactTmpl(secret, isCensorFct, censorFctTakesPath) {
-    return Object.keys(secret).map((path) => {
-      const { escPath, leadingBracket, path: arrPath } = secret[path];
+    return Object.keys(secret).map((path2) => {
+      const { escPath, leadingBracket, path: arrPath } = secret[path2];
       const skip = leadingBracket ? 1 : 0;
       const delim = leadingBracket ? "" : ".";
       const hops = [];
       var match;
-      while ((match = rx.exec(path)) !== null) {
+      while ((match = rx.exec(path2)) !== null) {
         const [, ix] = match;
         const { index, input } = match;
         if (index > skip)
@@ -9733,9 +9733,9 @@ var require_redactor = __commonJS((exports, module) => {
       }
       var existence = hops.map((p) => `o${delim}${p}`).join(" && ");
       if (existence.length === 0)
-        existence += `o${delim}${path} != null`;
+        existence += `o${delim}${path2} != null`;
       else
-        existence += ` && o${delim}${path} != null`;
+        existence += ` && o${delim}${path2} != null`;
       const circularDetection = `
       switch (true) {
         ${hops.reverse().map((p) => `
@@ -9749,12 +9749,12 @@ var require_redactor = __commonJS((exports, module) => {
       const censorArgs = censorFctTakesPath ? `val, ${JSON.stringify(arrPath)}` : `val`;
       return `
       if (${existence}) {
-        const val = o${delim}${path}
+        const val = o${delim}${path2}
         if (val === censor) {
           secret[${escPath}].precensored = true
         } else {
           secret[${escPath}].val = val
-          o${delim}${path} = ${isCensorFct ? `censor(${censorArgs})` : "censor"}
+          o${delim}${path2} = ${isCensorFct ? `censor(${censorArgs})` : "censor"}
           ${circularDetection}
         }
       }
@@ -9805,14 +9805,14 @@ var require_modifiers = __commonJS((exports, module) => {
       target[k] = values[i];
     }
   }
-  function groupRedact(o, path, censor, isCensorFct, censorFctTakesPath) {
-    const target = get(o, path);
+  function groupRedact(o, path2, censor, isCensorFct, censorFctTakesPath) {
+    const target = get(o, path2);
     if (target == null || typeof target === "string")
       return { keys: null, values: null, target, flat: true };
     const keys2 = Object.keys(target);
     const keysLength = keys2.length;
-    const pathLength = path.length;
-    const pathWithKey = censorFctTakesPath ? [...path] : undefined;
+    const pathLength = path2.length;
+    const pathWithKey = censorFctTakesPath ? [...path2] : undefined;
     const values = new Array(keysLength);
     for (var i = 0;i < keysLength; i++) {
       const key = keys2[i];
@@ -9830,30 +9830,30 @@ var require_modifiers = __commonJS((exports, module) => {
   }
   function nestedRestore(instructions) {
     for (let i = 0;i < instructions.length; i++) {
-      const { target, path, value } = instructions[i];
+      const { target, path: path2, value } = instructions[i];
       let current = target;
-      for (let i2 = path.length - 1;i2 > 0; i2--) {
-        current = current[path[i2]];
+      for (let i2 = path2.length - 1;i2 > 0; i2--) {
+        current = current[path2[i2]];
       }
-      current[path[0]] = value;
+      current[path2[0]] = value;
     }
   }
-  function nestedRedact(store, o, path, ns, censor, isCensorFct, censorFctTakesPath) {
-    const target = get(o, path);
+  function nestedRedact(store, o, path2, ns, censor, isCensorFct, censorFctTakesPath) {
+    const target = get(o, path2);
     if (target == null)
       return;
     const keys2 = Object.keys(target);
     const keysLength = keys2.length;
     for (var i = 0;i < keysLength; i++) {
       const key = keys2[i];
-      specialSet(store, target, key, path, ns, censor, isCensorFct, censorFctTakesPath);
+      specialSet(store, target, key, path2, ns, censor, isCensorFct, censorFctTakesPath);
     }
     return store;
   }
   function has(obj, prop) {
     return obj !== undefined && obj !== null ? "hasOwn" in Object ? Object.hasOwn(obj, prop) : Object.prototype.hasOwnProperty.call(obj, prop) : false;
   }
-  function specialSet(store, o, k, path, afterPath, censor, isCensorFct, censorFctTakesPath) {
+  function specialSet(store, o, k, path2, afterPath, censor, isCensorFct, censorFctTakesPath) {
     const afterPathLen = afterPath.length;
     const lastPathIndex = afterPathLen - 1;
     const originalKey = k;
@@ -9897,7 +9897,7 @@ var require_modifiers = __commonJS((exports, module) => {
           if (consecutive) {
             redactPathCurrent = node(redactPathCurrent, wck, depth);
             level = i;
-            ov = iterateNthLevel(wcov, level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, o[originalKey], depth + 1);
+            ov = iterateNthLevel(wcov, level - 1, k, path2, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, o[originalKey], depth + 1);
           } else {
             if (kIsWc || typeof wcov === "object" && wcov !== null && k in wcov) {
               if (kIsWc) {
@@ -9905,7 +9905,7 @@ var require_modifiers = __commonJS((exports, module) => {
               } else {
                 ov = wcov[k];
               }
-              nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path, originalKey, ...afterPath]) : censor(ov) : censor;
+              nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path2, originalKey, ...afterPath]) : censor(ov) : censor;
               if (kIsWc) {
                 const rv = restoreInstr(node(redactPathCurrent, wck, depth), ov, o[originalKey]);
                 store.push(rv);
@@ -9927,7 +9927,7 @@ var require_modifiers = __commonJS((exports, module) => {
       } else {
         ov = n[k];
         redactPathCurrent = node(redactPathCurrent, k, depth);
-        nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path, originalKey, ...afterPath]) : censor(ov) : censor;
+        nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path2, originalKey, ...afterPath]) : censor(ov) : censor;
         if (has(n, k) && nv === ov || nv === undefined && censor !== undefined) {} else {
           const rv = restoreInstr(redactPathCurrent, ov, o[originalKey]);
           store.push(rv);
@@ -9949,7 +9949,7 @@ var require_modifiers = __commonJS((exports, module) => {
     }
     return n;
   }
-  function iterateNthLevel(wcov, level, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth) {
+  function iterateNthLevel(wcov, level, k, path2, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth) {
     if (level === 0) {
       if (kIsWc || typeof wcov === "object" && wcov !== null && k in wcov) {
         if (kIsWc) {
@@ -9957,7 +9957,7 @@ var require_modifiers = __commonJS((exports, module) => {
         } else {
           ov = wcov[k];
         }
-        nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path, originalKey, ...afterPath]) : censor(ov) : censor;
+        nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [...path2, originalKey, ...afterPath]) : censor(ov) : censor;
         if (kIsWc) {
           const rv = restoreInstr(redactPathCurrent, ov, parent);
           store.push(rv);
@@ -9974,7 +9974,7 @@ var require_modifiers = __commonJS((exports, module) => {
     for (const key in wcov) {
       if (typeof wcov[key] === "object") {
         redactPathCurrent = node(redactPathCurrent, key, depth);
-        iterateNthLevel(wcov[key], level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth + 1);
+        iterateNthLevel(wcov[key], level - 1, k, path2, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth + 1);
       }
     }
   }
@@ -9996,12 +9996,12 @@ var require_modifiers = __commonJS((exports, module) => {
   }
   function restoreInstr(node2, value, target) {
     let current = node2;
-    const path = [];
+    const path2 = [];
     do {
-      path.push(current.key);
+      path2.push(current.key);
       current = current.parent;
     } while (current.parent != null);
-    return { path, value, target };
+    return { path: path2, value, target };
   }
 });
 
@@ -10025,10 +10025,10 @@ var require_restorer = __commonJS((exports, module) => {
     };
   }
   function resetTmpl(secret, paths) {
-    return paths.map((path) => {
-      const { circle, escPath, leadingBracket } = secret[path];
+    return paths.map((path2) => {
+      const { circle, escPath, leadingBracket } = secret[path2];
       const delim = leadingBracket ? "" : ".";
-      const reset = circle ? `o.${circle} = secret[${escPath}].val` : `o${delim}${path} = secret[${escPath}].val`;
+      const reset = circle ? `o.${circle} = secret[${escPath}].val` : `o${delim}${path2} = secret[${escPath}].val`;
       const clear = `secret[${escPath}].val = undefined`;
       return `
       if (secret[${escPath}].val !== undefined) {
@@ -19932,8 +19932,8 @@ var require_reporter = __commonJS((exports) => {
       errors: state.errors
     };
   };
-  function ReporterError(path, msg) {
-    this.path = path;
+  function ReporterError(path2, msg) {
+    this.path = path2;
     this.rethrow(msg);
   }
   inherits(ReporterError, Error);
@@ -25516,20 +25516,41 @@ function escapeObject(obj) {
 function isSerializableLike(obj) {
   return obj !== null && typeof obj === "object" && "lc_serializable" in obj && typeof obj.toJSON === "function";
 }
-function escapeIfNeeded(value) {
+function createNotImplemented(obj) {
+  let id;
+  if (obj !== null && typeof obj === "object")
+    if ("lc_id" in obj && Array.isArray(obj.lc_id))
+      id = obj.lc_id;
+    else
+      id = [obj.constructor?.name ?? "Object"];
+  else
+    id = [typeof obj];
+  return {
+    lc: 1,
+    type: "not_implemented",
+    id
+  };
+}
+function escapeIfNeeded(value, pathSet = /* @__PURE__ */ new WeakSet) {
   if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    if (pathSet.has(value))
+      return createNotImplemented(value);
     if (isSerializableLike(value))
       return value;
+    pathSet.add(value);
     const record = value;
-    if (needsEscaping(record))
+    if (needsEscaping(record)) {
+      pathSet.delete(value);
       return escapeObject(record);
+    }
     const result = {};
     for (const [key, val] of Object.entries(record))
-      result[key] = escapeIfNeeded(val);
+      result[key] = escapeIfNeeded(val, pathSet);
+    pathSet.delete(value);
     return result;
   }
   if (Array.isArray(value))
-    return value.map((item) => escapeIfNeeded(item));
+    return value.map((item) => escapeIfNeeded(item, pathSet));
   return value;
 }
 
@@ -25633,8 +25654,10 @@ var Serializable = class Serializable2 {
         write[last] = write[last] || read[last];
     });
     const escapedKwargs = {};
+    const pathSet = /* @__PURE__ */ new WeakSet;
+    pathSet.add(this);
     for (const [key, value] of Object.entries(kwargs))
-      escapedKwargs[key] = escapeIfNeeded(value);
+      escapedKwargs[key] = escapeIfNeeded(value, pathSet);
     const kwargsWithSecrets = Object.keys(secrets).length ? replaceSecrets(escapedKwargs, secrets) : escapedKwargs;
     const processedKwargs = mapKeys(kwargsWithSecrets, keyToJson, aliases);
     return {
@@ -26571,7 +26594,11 @@ var BaseMessage = class extends Serializable {
     return convertToFormattedString(this, format);
   }
 };
-function _mergeDicts(left = {}, right = {}) {
+function _mergeDicts(left, right) {
+  if (left === undefined && right === undefined)
+    return;
+  if (left === undefined || right === undefined)
+    return left ?? right;
   const merged = { ...left };
   for (const [key, value] of Object.entries(right))
     if (merged[key] == null)
@@ -26593,6 +26620,8 @@ function _mergeDicts(left = {}, right = {}) {
           merged[key] = value;
       } else
         merged[key] += value;
+    else if (typeof merged[key] === "number")
+      merged[key] = merged[key] + value;
     else if (typeof merged[key] === "object" && !Array.isArray(merged[key]))
       merged[key] = _mergeDicts(merged[key], value);
     else if (Array.isArray(merged[key]))
@@ -27411,7 +27440,7 @@ function getTranslator(modelProvider) {
 
 // ../../node_modules/@langchain/core/dist/messages/metadata.js
 function mergeResponseMetadata(a, b) {
-  const output = _mergeDicts(a ?? {}, b ?? {});
+  const output = _mergeDicts(a, b) ?? {};
   return output;
 }
 function mergeModalitiesTokenDetails(a, b) {
@@ -27489,8 +27518,8 @@ Please upgrade your packages to versions that set`,
         ].join(" "));
       try {
         if (!(rawToolCalls == null) && toolCalls === undefined) {
-          const [toolCalls$1, invalidToolCalls] = defaultToolCallParser(rawToolCalls);
-          initParams.tool_calls = toolCalls$1 ?? [];
+          const [parsedToolCalls, invalidToolCalls] = defaultToolCallParser(rawToolCalls);
+          initParams.tool_calls = parsedToolCalls ?? [];
           initParams.invalid_tool_calls = invalidToolCalls ?? [];
         } else {
           initParams.tool_calls = initParams.tool_calls ?? [];
@@ -27505,12 +27534,13 @@ Please upgrade your packages to versions that set`,
         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
-        })));
+        if (initParams.tool_calls)
+          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) => ({
@@ -27543,7 +27573,6 @@ Please upgrade your packages to versions that set`,
     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,
@@ -27587,12 +27616,16 @@ var AIMessageChunk = class extends BaseMessageChunk {
         tool_call_chunks: [],
         usage_metadata: fields.usage_metadata !== undefined ? fields.usage_metadata : undefined
       };
-    else
+    else {
+      const collapsed = collapseToolCallChunks(fields.tool_call_chunks ?? []);
       initParams = {
         ...fields,
-        ...collapseToolCallChunks(fields.tool_call_chunks ?? []),
+        tool_call_chunks: collapsed.tool_call_chunks,
+        tool_calls: collapsed.tool_calls,
+        invalid_tool_calls: collapsed.invalid_tool_calls,
         usage_metadata: fields.usage_metadata !== undefined ? fields.usage_metadata : undefined
       };
+    }
     super(initParams);
     this.tool_call_chunks = initParams.tool_call_chunks ?? this.tool_call_chunks;
     this.tool_calls = initParams.tool_calls ?? this.tool_calls;
@@ -27672,21 +27705,29 @@ function getBufferString(messages, humanPrefix = "Human", aiPrefix = "AI") {
   const string_messages = [];
   for (const m of messages) {
     let role;
-    if (m._getType() === "human")
+    if (m.type === "human")
       role = humanPrefix;
-    else if (m._getType() === "ai")
+    else if (m.type === "ai")
       role = aiPrefix;
-    else if (m._getType() === "system")
+    else if (m.type === "system")
       role = "System";
-    else if (m._getType() === "tool")
+    else if (m.type === "tool")
       role = "Tool";
-    else if (m._getType() === "generic")
+    else if (m.type === "generic")
       role = m.role;
     else
-      throw new Error(`Got unsupported message type: ${m._getType()}`);
+      throw new Error(`Got unsupported message type: ${m.type}`);
     const nameStr = m.name ? `${m.name}, ` : "";
-    const readableContent = typeof m.content === "string" ? m.content : JSON.stringify(m.content, null, 2);
-    string_messages.push(`${role}: ${nameStr}${readableContent}`);
+    const readableContent = m.text;
+    let message = `${role}: ${nameStr}${readableContent}`;
+    if (m.type === "ai") {
+      const aiMessage = m;
+      if (aiMessage.tool_calls && aiMessage.tool_calls.length > 0)
+        message += JSON.stringify(aiMessage.tool_calls);
+      else if (aiMessage.additional_kwargs && "function_call" in aiMessage.additional_kwargs)
+        message += JSON.stringify(aiMessage.additional_kwargs.function_call);
+    }
+    string_messages.push(message);
   }
   return string_messages.join(`
 `);
@@ -28002,8 +28043,232 @@ function uuid7FromTime(timestamp) {
   const msecs = typeof timestamp === "string" ? Date.parse(timestamp) : timestamp;
   return v72({ msecs, seq: 0 });
 }
+// ../../node_modules/langsmith/dist/utils/prompts_cache_fs.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+function dumpCache(filePath, entries) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const data = { entries };
+  const tempPath = `${filePath}.tmp`;
+  try {
+    fs.writeFileSync(tempPath, JSON.stringify(data, null, 2));
+    fs.renameSync(tempPath, filePath);
+  } catch (e) {
+    if (fs.existsSync(tempPath)) {
+      fs.unlinkSync(tempPath);
+    }
+    throw e;
+  }
+}
+function loadCache(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(content);
+    return data.entries ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// ../../node_modules/langsmith/dist/utils/prompts_cache.js
+function isStale(entry, ttlSeconds) {
+  if (ttlSeconds === null) {
+    return false;
+  }
+  const ageMs = Date.now() - entry.createdAt;
+  return ageMs > ttlSeconds * 1000;
+}
+
+class Cache {
+  constructor(config = {}) {
+    Object.defineProperty(this, "cache", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: new Map
+    });
+    Object.defineProperty(this, "maxSize", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
+    Object.defineProperty(this, "ttlSeconds", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
+    Object.defineProperty(this, "refreshIntervalSeconds", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
+    Object.defineProperty(this, "fetchFunc", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
+    Object.defineProperty(this, "refreshTimer", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
+    Object.defineProperty(this, "_metrics", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {
+        hits: 0,
+        misses: 0,
+        refreshes: 0,
+        refreshErrors: 0
+      }
+    });
+    this.maxSize = config.maxSize ?? 100;
+    this.ttlSeconds = config.ttlSeconds ?? 3600;
+    this.refreshIntervalSeconds = config.refreshIntervalSeconds ?? 60;
+    this.fetchFunc = config.fetchFunc;
+    if (this.fetchFunc && this.ttlSeconds !== null) {
+      this.startRefreshLoop();
+    }
+  }
+  get metrics() {
+    return { ...this._metrics };
+  }
+  get totalRequests() {
+    return this._metrics.hits + this._metrics.misses;
+  }
+  get hitRate() {
+    const total = this.totalRequests;
+    return total > 0 ? this._metrics.hits / total : 0;
+  }
+  resetMetrics() {
+    this._metrics = {
+      hits: 0,
+      misses: 0,
+      refreshes: 0,
+      refreshErrors: 0
+    };
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this._metrics.misses += 1;
+      return;
+    }
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    this._metrics.hits += 1;
+    return entry.value;
+  }
+  set(key, value) {
+    if (!this.cache.has(key) && this.cache.size >= this.maxSize) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== undefined) {
+        this.cache.delete(oldestKey);
+      }
+    }
+    const entry = {
+      value,
+      createdAt: Date.now()
+    };
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+  }
+  invalidate(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+  stop() {
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = undefined;
+    }
+  }
+  dump(filePath) {
+    const entries = {};
+    for (const [key, entry] of this.cache.entries()) {
+      entries[key] = entry.value;
+    }
+    dumpCache(filePath, entries);
+  }
+  load(filePath) {
+    const entries = loadCache(filePath);
+    if (!entries) {
+      return 0;
+    }
+    let loaded = 0;
+    const now = Date.now();
+    for (const [key, value] of Object.entries(entries)) {
+      if (this.cache.size >= this.maxSize) {
+        break;
+      }
+      const entry = {
+        value,
+        createdAt: now
+      };
+      this.cache.set(key, entry);
+      loaded += 1;
+    }
+    return loaded;
+  }
+  startRefreshLoop() {
+    this.refreshTimer = setInterval(() => {
+      this.refreshStaleEntries().catch((e) => {
+        console.warn("Unexpected error in cache refresh loop:", e);
+      });
+    }, this.refreshIntervalSeconds * 1000);
+    if (this.refreshTimer.unref) {
+      this.refreshTimer.unref();
+    }
+  }
+  getStaleKeys() {
+    const staleKeys = [];
+    for (const [key, entry] of this.cache.entries()) {
+      if (isStale(entry, this.ttlSeconds)) {
+        staleKeys.push(key);
+      }
+    }
+    return staleKeys;
+  }
+  async refreshStaleEntries() {
+    if (!this.fetchFunc) {
+      return;
+    }
+    const staleKeys = this.getStaleKeys();
+    if (staleKeys.length === 0) {
+      return;
+    }
+    for (const key of staleKeys) {
+      try {
+        const newValue = await this.fetchFunc(key);
+        this.set(key, newValue);
+        this._metrics.refreshes += 1;
+      } catch (e) {
+        this._metrics.refreshErrors += 1;
+        console.warn(`Failed to refresh cache entry ${key}:`, e);
+      }
+    }
+  }
+}
+
 // ../../node_modules/langsmith/dist/index.js
-var __version__ = "0.4.4";
+var __version__ = "0.4.5";
 
 // ../../node_modules/langsmith/dist/utils/env.js
 var globalEnv;
@@ -29531,6 +29796,12 @@ class Client {
       writable: true,
       value: undefined
     });
+    Object.defineProperty(this, "_cache", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
     Object.defineProperty(this, "multipartStreamingDisabled", {
       enumerable: true,
       configurable: true,
@@ -29596,6 +29867,13 @@ class Client {
       this.langSmithToOTELTranslator = new LangSmithToOTELTranslator;
     }
     this.cachedLSEnvVarsForMetadata = getLangSmithEnvVarsMetadata();
+    if (config.cache === true) {
+      this._cache = new Cache;
+    } else if (config.cache && typeof config.cache === "object") {
+      this._cache = config.cache;
+    } else {
+      this._cache = undefined;
+    }
   }
   static getDefaultClientConfig() {
     const apiKey = getLangSmithEnvironmentVariable("API_KEY");
@@ -29648,9 +29926,9 @@ class Client {
     }
     return headers;
   }
-  _getPlatformEndpointPath(path) {
+  _getPlatformEndpointPath(path2) {
     const needsV1Prefix = this.apiUrl.slice(-3) !== "/v1" && this.apiUrl.slice(-4) !== "/v1/";
-    return needsV1Prefix ? `/v1/platform/${path}` : `/platform/${path}`;
+    return needsV1Prefix ? `/v1/platform/${path2}` : `/platform/${path2}`;
   }
   async processInputs(inputs) {
     if (this.hideInputs === false) {
@@ -29686,9 +29964,9 @@ class Client {
     }
     return runParams;
   }
-  async _getResponse(path, queryParams) {
+  async _getResponse(path2, queryParams) {
     const paramsString = queryParams?.toString() ?? "";
-    const url = `${this.apiUrl}${path}?${paramsString}`;
+    const url = `${this.apiUrl}${path2}?${paramsString}`;
     const response = await this.caller.call(async () => {
       const res = await this._fetch(url, {
         method: "GET",
@@ -29696,22 +29974,22 @@ class Client {
         signal: AbortSignal.timeout(this.timeout_ms),
         ...this.fetchOptions
       });
-      await raiseForStatus(res, `fetch ${path}`);
+      await raiseForStatus(res, `fetch ${path2}`);
       return res;
     });
     return response;
   }
-  async _get(path, queryParams) {
-    const response = await this._getResponse(path, queryParams);
+  async _get(path2, queryParams) {
+    const response = await this._getResponse(path2, queryParams);
     return response.json();
   }
-  async* _getPaginated(path, queryParams = new URLSearchParams, transform) {
+  async* _getPaginated(path2, queryParams = new URLSearchParams, transform) {
     let offset = Number(queryParams.get("offset")) || 0;
     const limit = Number(queryParams.get("limit")) || 100;
     while (true) {
       queryParams.set("offset", String(offset));
       queryParams.set("limit", String(limit));
-      const url = `${this.apiUrl}${path}?${queryParams}`;
+      const url = `${this.apiUrl}${path2}?${queryParams}`;
       const response = await this.caller.call(async () => {
         const res = await this._fetch(url, {
           method: "GET",
@@ -29719,7 +29997,7 @@ class Client {
           signal: AbortSignal.timeout(this.timeout_ms),
           ...this.fetchOptions
         });
-        await raiseForStatus(res, `fetch ${path}`);
+        await raiseForStatus(res, `fetch ${path2}`);
         return res;
       });
       const items = transform ? transform(await response.json()) : await response.json();
@@ -29733,19 +30011,19 @@ class Client {
       offset += items.length;
     }
   }
-  async* _getCursorPaginatedList(path, body = null, requestMethod = "POST", dataKey = "runs") {
+  async* _getCursorPaginatedList(path2, body = null, requestMethod = "POST", dataKey = "runs") {
     const bodyParams = body ? { ...body } : {};
     while (true) {
       const body2 = JSON.stringify(bodyParams);
       const response = await this.caller.call(async () => {
-        const res = await this._fetch(`${this.apiUrl}${path}`, {
+        const res = await this._fetch(`${this.apiUrl}${path2}`, {
           method: requestMethod,
           headers: { ...this.headers, "Content-Type": "application/json" },
           signal: AbortSignal.timeout(this.timeout_ms),
           ...this.fetchOptions,
           body: body2
         });
-        await raiseForStatus(res, `fetch ${path}`);
+        await raiseForStatus(res, `fetch ${path2}`);
         return res;
       });
       const responseBody = await response.json();
@@ -30581,8 +30859,8 @@ Context: ${context}`);
       limit: Number(limit) || 100
     };
     let currentOffset = Number(offset) || 0;
-    const path = "/runs/group";
-    const url = `${this.apiUrl}${path}`;
+    const path2 = "/runs/group";
+    const url = `${this.apiUrl}${path2}`;
     while (true) {
       const currentBody = {
         ...baseBody,
@@ -30598,7 +30876,7 @@ Context: ${context}`);
           ...this.fetchOptions,
           body
         });
-        await raiseForStatus(res, `Failed to fetch ${path}`);
+        await raiseForStatus(res, `Failed to fetch ${path2}`);
         return res;
       });
       const items = await response.json();
@@ -30908,20 +31186,20 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
     return result;
   }
   async hasProject({ projectId, projectName }) {
-    let path = "/sessions";
+    let path2 = "/sessions";
     const params = new URLSearchParams;
     if (projectId !== undefined && projectName !== undefined) {
       throw new Error("Must provide either projectName or projectId, not both");
     } else if (projectId !== undefined) {
       assertUuid(projectId);
-      path += `/${projectId}`;
+      path2 += `/${projectId}`;
     } else if (projectName !== undefined) {
       params.append("name", projectName);
     } else {
       throw new Error("Must provide projectName or projectId");
     }
     const response = await this.caller.call(async () => {
-      const res = await this._fetch(`${this.apiUrl}${path}?${params}`, {
+      const res = await this._fetch(`${this.apiUrl}${path2}?${params}`, {
         method: "GET",
         headers: this.headers,
         signal: AbortSignal.timeout(this.timeout_ms),
@@ -30944,13 +31222,13 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
     }
   }
   async readProject({ projectId, projectName, includeStats }) {
-    let path = "/sessions";
+    let path2 = "/sessions";
     const params = new URLSearchParams;
     if (projectId !== undefined && projectName !== undefined) {
       throw new Error("Must provide either projectName or projectId, not both");
     } else if (projectId !== undefined) {
       assertUuid(projectId);
-      path += `/${projectId}`;
+      path2 += `/${projectId}`;
     } else if (projectName !== undefined) {
       params.append("name", projectName);
     } else {
@@ -30959,7 +31237,7 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
     if (includeStats !== undefined) {
       params.append("include_stats", includeStats.toString());
     }
-    const response = await this._get(path, params);
+    const response = await this._get(path2, params);
     let result;
     if (Array.isArray(response)) {
       if (response.length === 0) {
@@ -31122,19 +31400,19 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
     return result;
   }
   async readDataset({ datasetId, datasetName }) {
-    let path = "/datasets";
+    let path2 = "/datasets";
     const params = new URLSearchParams({ limit: "1" });
     if (datasetId && datasetName) {
       throw new Error("Must provide either datasetName or datasetId, not both");
     } else if (datasetId) {
       assertUuid(datasetId);
-      path += `/${datasetId}`;
+      path2 += `/${datasetId}`;
     } else if (datasetName) {
       params.append("name", datasetName);
     } else {
       throw new Error("Must provide datasetName or datasetId");
     }
-    const response = await this._get(path, params);
+    const response = await this._get(path2, params);
     let result;
     if (Array.isArray(response)) {
       if (response.length === 0) {
@@ -31175,20 +31453,20 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
     return response;
   }
   async readDatasetOpenaiFinetuning({ datasetId, datasetName }) {
-    const path = "/datasets";
+    const path2 = "/datasets";
     if (datasetId !== undefined) {} else if (datasetName !== undefined) {
       datasetId = (await this.readDataset({ datasetName })).id;
     } else {
       throw new Error("Must provide either datasetName or datasetId");
     }
-    const response = await this._getResponse(`${path}/${datasetId}/openai_ft`);
+    const response = await this._getResponse(`${path2}/${datasetId}/openai_ft`);
     const datasetText = await response.text();
     const dataset = datasetText.trim().split(`
 `).map((line) => JSON.parse(line));
     return dataset;
   }
   async* listDatasets({ limit = 100, offset = 0, datasetIds, datasetName, datasetNameContains, metadata } = {}) {
-    const path = "/datasets";
+    const path2 = "/datasets";
     const params = new URLSearchParams({
       limit: limit.toString(),
       offset: offset.toString()
@@ -31207,7 +31485,7 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
     if (metadata !== undefined) {
       params.append("metadata", JSON.stringify(metadata));
     }
-    for await (const datasets of this._getPaginated(path, params)) {
+    for await (const datasets of this._getPaginated(path2, params)) {
       yield* datasets;
     }
   }
@@ -31256,7 +31534,7 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
     });
   }
   async deleteDataset({ datasetId, datasetName }) {
-    let path = "/datasets";
+    let path2 = "/datasets";
     let datasetId_ = datasetId;
     if (datasetId !== undefined && datasetName !== undefined) {
       throw new Error("Must provide either datasetName or datasetId, not both");
@@ -31266,18 +31544,18 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
     }
     if (datasetId_ !== undefined) {
       assertUuid(datasetId_);
-      path += `/${datasetId_}`;
+      path2 += `/${datasetId_}`;
     } else {
       throw new Error("Must provide datasetName or datasetId");
     }
     await this.caller.call(async () => {
-      const res = await this._fetch(this.apiUrl + path, {
+      const res = await this._fetch(this.apiUrl + path2, {
         method: "DELETE",
         headers: this.headers,
         signal: AbortSignal.timeout(this.timeout_ms),
         ...this.fetchOptions
       });
-      await raiseForStatus(res, `delete ${path}`, true);
+      await raiseForStatus(res, `delete ${path2}`, true);
       return res;
     });
   }
@@ -31438,8 +31716,8 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
   }
   async readExample(exampleId) {
     assertUuid(exampleId);
-    const path = `/examples/${exampleId}`;
-    const rawExample = await this._get(path);
+    const path2 = `/examples/${exampleId}`;
+    const rawExample = await this._get(path2);
     const { attachment_urls, ...rest } = rawExample;
     const example = rest;
     if (attachment_urls) {
@@ -31522,24 +31800,24 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
   }
   async deleteExample(exampleId) {
     assertUuid(exampleId);
-    const path = `/examples/${exampleId}`;
+    const path2 = `/examples/${exampleId}`;
     await this.caller.call(async () => {
-      const res = await this._fetch(this.apiUrl + path, {
+      const res = await this._fetch(this.apiUrl + path2, {
         method: "DELETE",
         headers: this.headers,
         signal: AbortSignal.timeout(this.timeout_ms),
         ...this.fetchOptions
       });
-      await raiseForStatus(res, `delete ${path}`, true);
+      await raiseForStatus(res, `delete ${path2}`, true);
       return res;
     });
   }
   async deleteExamples(exampleIds, options) {
     exampleIds.forEach((id) => assertUuid(id));
     if (options?.hardDelete) {
-      const path = this._getPlatformEndpointPath("datasets/examples/delete");
+      const path2 = this._getPlatformEndpointPath("datasets/examples/delete");
       await this.caller.call(async () => {
-        const res = await this._fetch(`${this.apiUrl}${path}`, {
+        const res = await this._fetch(`${this.apiUrl}${path2}`, {
           method: "POST",
           headers: { ...this.headers, "Content-Type": "application/json" },
           body: JSON.stringify({
@@ -31761,21 +32039,21 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
   }
   async readFeedback(feedbackId) {
     assertUuid(feedbackId);
-    const path = `/feedback/${feedbackId}`;
-    const response = await this._get(path);
+    const path2 = `/feedback/${feedbackId}`;
+    const response = await this._get(path2);
     return response;
   }
   async deleteFeedback(feedbackId) {
     assertUuid(feedbackId);
-    const path = `/feedback/${feedbackId}`;
+    const path2 = `/feedback/${feedbackId}`;
     await this.caller.call(async () => {
-      const res = await this._fetch(this.apiUrl + path, {
+      const res = await this._fetch(this.apiUrl + path2, {
         method: "DELETE",
         headers: this.headers,
         signal: AbortSignal.timeout(this.timeout_ms),
         ...this.fetchOptions
       });
-      await raiseForStatus(res, `delete ${path}`, true);
+      await raiseForStatus(res, `delete ${path2}`, true);
       return res;
     });
   }
@@ -32435,7 +32713,11 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
     });
     return response.json();
   }
-  async pullPromptCommit(promptIdentifier, options) {
+  _getPromptCacheKey(promptIdentifier, includeModel) {
+    const suffix = includeModel ? ":with_model" : "";
+    return `${promptIdentifier}${suffix}`;
+  }
+  async _fetchPromptFromApi(promptIdentifier, options) {
     const [owner, promptName, commitHash] = parsePromptIdentifier(promptIdentifier);
     const response = await this.caller.call(async () => {
       const res = await this._fetch(`${this.apiUrl}/commits/${owner}/${promptName}/${commitHash}${options?.includeModel ? "?include_model=true" : ""}`, {
@@ -32456,9 +32738,23 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
       examples: result.examples
     };
   }
+  async pullPromptCommit(promptIdentifier, options) {
+    if (!options?.skipCache && this._cache) {
+      const cacheKey = this._getPromptCacheKey(promptIdentifier, options?.includeModel);
+      const cached = this._cache.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+      const result = await this._fetchPromptFromApi(promptIdentifier, options);
+      this._cache.set(cacheKey, result);
+      return result;
+    }
+    return this._fetchPromptFromApi(promptIdentifier, options);
+  }
   async _pullPrompt(promptIdentifier, options) {
     const promptObject = await this.pullPromptCommit(promptIdentifier, {
-      includeModel: options?.includeModel
+      includeModel: options?.includeModel,
+      skipCache: options?.skipCache
     });
     const prompt = JSON.stringify(promptObject.manifest);
     return prompt;
@@ -32540,6 +32836,14 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
       throw new Error(`Invalid public ${kind} URL or token: ${urlOrToken}`);
     }
   }
+  get cache() {
+    return this._cache;
+  }
+  cleanup() {
+    if (this._cache) {
+      this._cache.stop();
+    }
+  }
   async awaitPendingTraceBatches() {
     if (this.manualFlushMode) {
       console.warn("[WARNING]: When tracing in manual flush mode, you must call `await client.flush()` manually to submit trace batches.");
@@ -35261,13 +35565,13 @@ function isInteger(str) {
   }
   return true;
 }
-function escapePathComponent(path) {
-  if (path.indexOf("/") === -1 && path.indexOf("~") === -1)
-    return path;
-  return path.replace(/~/g, "~0").replace(/\//g, "~1");
+function escapePathComponent(path2) {
+  if (path2.indexOf("/") === -1 && path2.indexOf("~") === -1)
+    return path2;
+  return path2.replace(/~/g, "~0").replace(/\//g, "~1");
 }
-function unescapePathComponent(path) {
-  return path.replace(/~1/g, "/").replace(/~0/g, "~");
+function unescapePathComponent(path2) {
+  return path2.replace(/~1/g, "/").replace(/~0/g, "~");
 }
 function hasUndefined(obj) {
   if (obj === undefined)
@@ -35483,8 +35787,8 @@ function applyOperation(document2, operation, validateOperation = false, mutateD
   } else {
     if (!mutateDocument)
       document2 = _deepClone(document2);
-    const path = operation.path || "";
-    const keys = path.split("/");
+    const path2 = operation.path || "";
+    const keys = path2.split("/");
     let obj = document2;
     let t = 1;
     let len = keys.length;
@@ -39963,10 +40267,10 @@ var Runnable = class extends Serializable {
       }
       const paths = log.ops.filter((op) => op.path.startsWith("/logs/")).map((op) => op.path.split("/")[2]);
       const dedupedPaths = [...new Set(paths)];
-      for (const path of dedupedPaths) {
+      for (const path2 of dedupedPaths) {
         let eventType;
         let data = {};
-        const logEntry = runLog.state.logs[path];
+        const logEntry = runLog.state.logs[path2];
         if (logEntry.end_time === undefined)
           if (logEntry.streamed_output.length > 0)
             eventType = "stream";
@@ -42064,17 +42368,17 @@ function findEnvFile(startDir, filenames = [".env", ".env.local"]) {
   if (typeof process === "undefined" || !process.cwd) {
     return null;
   }
-  const fs = __require("node:fs");
-  const path = __require("node:path");
+  const fs2 = __require("node:fs");
+  const path2 = __require("node:path");
   let currentDir = startDir || process.cwd();
   while (true) {
     for (const filename of filenames) {
-      const candidate = path.join(currentDir, filename);
-      if (fs.existsSync(candidate)) {
+      const candidate = path2.join(currentDir, filename);
+      if (fs2.existsSync(candidate)) {
         return candidate;
       }
     }
-    const parentDir = path.dirname(currentDir);
+    const parentDir = path2.dirname(currentDir);
     if (parentDir === currentDir) {
       break;
     }
@@ -44954,9 +45258,9 @@ var getContentTypeFromMimeType = (mimeType) => {
   }
   return;
 };
-function getLocalServerUrl(path) {
+function getLocalServerUrl(path2) {
   const port = getEnv3("SERVER_PORT", "3000");
-  return `http://localhost:${port}${path}`;
+  return `http://localhost:${port}${path2}`;
 }
 // src/schemas/character.ts
 import { z as z3 } from "zod";
@@ -45473,8 +45777,8 @@ class ActionStreamFilter {
 // src/utils/paths.ts
 var pathJoin = (...parts) => {
   if (typeof process !== "undefined" && process.platform) {
-    const path = __require("node:path");
-    return path.join(...parts);
+    const path2 = __require("node:path");
+    return path2.join(...parts);
   }
   return parts.filter((part) => part).join("/").replace(/\/+/g, "/").replace(/\/$/, "");
 };
@@ -48076,66 +48380,41 @@ class AgentRuntime {
     }
     this.messageService = new DefaultMessageService;
     const skipMigrations = options?.skipMigrations ?? false;
-    if (skipMigrations) {
-      this.logger.debug({ src: "agent", agentId: this.agentId }, "Skipping plugin migrations");
-    } else {
-      this.logger.debug({ src: "agent", agentId: this.agentId }, "Running plugin migrations");
-      await this.runPluginMigrations();
-      this.logger.debug({ src: "agent", agentId: this.agentId }, "Plugin migrations completed");
-    }
     const existingAgent = await this.ensureAgentExists({
       ...this.character,
       id: this.agentId
     });
     if (!existingAgent) {
-      const errorMsg = `Agent ${this.agentId} does not exist in database after ensureAgentExists call`;
-      throw new Error(errorMsg);
+      throw new Error(`Agent ${this.agentId} does not exist in database after ensureAgentExists`);
     }
-    if (existingAgent.settings) {
-      this.character.settings = {
-        ...existingAgent.settings,
-        ...this.character.settings
-      };
-      const dbSecrets = existingAgent.settings.secrets && typeof existingAgent.settings.secrets === "object" ? existingAgent.settings.secrets : {};
-      const settingsSecrets = this.character.settings.secrets && typeof this.character.settings.secrets === "object" ? this.character.settings.secrets : {};
-      const characterSecrets = this.character.secrets && typeof this.character.secrets === "object" ? this.character.secrets : {};
-      const mergedSecrets = {
-        ...dbSecrets,
-        ...characterSecrets,
-        ...settingsSecrets
-      };
-      if (Object.keys(mergedSecrets).length > 0) {
-        const filteredSecrets = {};
-        for (const [key, value] of Object.entries(mergedSecrets)) {
-          if (value !== null && value !== undefined) {
-            filteredSecrets[key] = value;
-          }
-        }
-        if (Object.keys(filteredSecrets).length > 0) {
-          this.character.secrets = filteredSecrets;
-          this.character.settings.secrets = filteredSecrets;
-        }
-      }
-    }
-    let agentEntity = await this.getEntityById(this.agentId);
-    if (!agentEntity) {
-      const created = await this.createEntity({
+    this.mergeAgentSettings(existingAgent);
+    await Promise.all([
+      this.ensureWorldExists({
+        id: this.agentId,
+        name: `${this.character.name}'s World`,
+        agentId: this.agentId,
+        messageServerId: this.agentId
+      }),
+      skipMigrations ? Promise.resolve() : (async () => {
+        this.logger.debug({ src: "agent", agentId: this.agentId }, "Running plugin migrations");
+        await this.runPluginMigrations();
+        this.logger.debug({ src: "agent", agentId: this.agentId }, "Plugin migrations completed");
+      })()
+    ]);
+    const [agentEntity, existingRoom, participants] = await Promise.all([
+      this.ensureEntity({
         id: this.agentId,
         names: [this.character.name],
         metadata: {},
         agentId: existingAgent.id
-      });
-      if (!created) {
-        const errorMsg = `Failed to create entity for agent ${this.agentId}`;
-        throw new Error(errorMsg);
-      }
-      agentEntity = await this.getEntityById(this.agentId);
-      if (!agentEntity)
-        throw new Error(`Agent entity not found for ${this.agentId}`);
-      this.logger.debug({ src: "agent", agentId: this.agentId }, "Agent entity created");
+      }),
+      this.getRoom(this.agentId),
+      this.adapter.getParticipantsForRoom(this.agentId)
+    ]);
+    if (!agentEntity) {
+      throw new Error(`Failed to ensure entity for agent ${this.agentId}`);
     }
-    const room = await this.getRoom(this.agentId);
-    if (!room) {
+    if (!existingRoom) {
       await this.createRoom({
         id: this.agentId,
         name: this.character.name,
@@ -48145,8 +48424,8 @@ class AgentRuntime {
         messageServerId: this.agentId,
         worldId: this.agentId
       });
+      this.logger.debug({ src: "agent", agentId: this.agentId }, "Agent room created");
     }
-    const participants = await this.adapter.getParticipantsForRoom(this.agentId);
     if (!participants.includes(this.agentId)) {
       const added = await this.addParticipant(this.agentId, this.agentId);
       if (!added) {
@@ -48165,6 +48444,34 @@ class AgentRuntime {
       this.initResolver = undefined;
     }
   }
+  mergeAgentSettings(existingAgent) {
+    if (!existingAgent.settings)
+      return;
+    this.character.settings = {
+      ...existingAgent.settings,
+      ...this.character.settings
+    };
+    const dbSecrets = existingAgent.settings.secrets && typeof existingAgent.settings.secrets === "object" ? existingAgent.settings.secrets : {};
+    const settingsSecrets = this.character.settings.secrets && typeof this.character.settings.secrets === "object" ? this.character.settings.secrets : {};
+    const characterSecrets = this.character.secrets && typeof this.character.secrets === "object" ? this.character.secrets : {};
+    const mergedSecrets = {
+      ...dbSecrets,
+      ...characterSecrets,
+      ...settingsSecrets
+    };
+    if (Object.keys(mergedSecrets).length > 0) {
+      const filteredSecrets = {};
+      for (const [key, value] of Object.entries(mergedSecrets)) {
+        if (value !== null && value !== undefined) {
+          filteredSecrets[key] = value;
+        }
+      }
+      if (Object.keys(filteredSecrets).length > 0) {
+        this.character.secrets = filteredSecrets;
+        this.character.settings.secrets = filteredSecrets;
+      }
+    }
+  }
   async runPluginMigrations() {
     if (!this.adapter) {
       this.logger.warn({ src: "agent", agentId: this.agentId }, "Database adapter not found, skipping plugin migrations");
@@ -48676,9 +48983,9 @@ class AgentRuntime {
       chunks[chunks.length - 1].push(item);
       return chunks;
     }, []);
-    const roomIds = rooms.map((r2) => r2.id);
+    const roomIds = rooms.map((r) => r.id);
     const roomExistsCheck = await this.getRoomsByIds(roomIds);
-    const roomsIdExists = roomExistsCheck?.map((r2) => r2.id);
+    const roomsIdExists = roomExistsCheck?.map((r) => r.id);
     const roomsToCreate = roomIds.filter((id) => !roomsIdExists?.includes(id));
     const rf = {
       worldId: world.id,
@@ -48688,36 +48995,27 @@ class AgentRuntime {
     };
     if (roomsToCreate.length) {
       this.logger.debug({ src: "agent", agentId: this.agentId, count: roomsToCreate.length }, "Creating rooms");
-      const roomObjsToCreate = rooms.filter((r2) => roomsToCreate.includes(r2.id)).map((r2) => ({ ...r2, ...rf, type: r2.type || "GROUP" /* GROUP */ }));
+      const roomObjsToCreate = rooms.filter((r) => roomsToCreate.includes(r.id)).map((r) => ({ ...r, ...rf, type: r.type || "GROUP" /* GROUP */ }));
       await this.createRooms(roomObjsToCreate);
     }
     const entityIds = entities.map((e) => e.id).filter((id) => id !== undefined);
-    const entityExistsCheck = await this.adapter.getEntitiesByIds(entityIds);
-    const entitiesToUpdate = entityExistsCheck?.map((e) => e.id).filter((id) => id !== undefined) || [];
-    const entitiesToCreate = entities.filter((e) => e.id !== undefined && !entitiesToUpdate.includes(e.id));
-    const r = {
-      roomId: firstRoom.id,
-      channelId: firstRoom.channelId,
-      type: firstRoom.type
-    };
-    const wf = {
-      worldId: world.id,
-      messageServerId: world.messageServerId
-    };
-    if (entitiesToCreate.length) {
-      this.logger.debug({ src: "agent", agentId: this.agentId, count: entitiesToCreate.length }, "Creating entities");
-      const ef = {
-        ...r,
-        ...wf,
+    if (entities.length) {
+      this.logger.debug({ src: "agent", agentId: this.agentId, count: entities.length }, "Creating entities");
+      const entityFields = {
+        roomId: firstRoom.id,
+        channelId: firstRoom.channelId,
+        type: firstRoom.type,
+        worldId: world.id,
+        messageServerId: world.messageServerId,
         source,
         agentId: this.agentId
       };
-      const entitiesToCreateWFields = entitiesToCreate.map((e) => ({
+      const entitiesWithFields = entities.filter((e) => e.id !== undefined).map((e) => ({
         ...e,
-        ...ef,
+        ...entityFields,
         metadata: e.metadata || {}
       }));
-      const batches = chunkArray(entitiesToCreateWFields, 5000);
+      const batches = chunkArray(entitiesWithFields, 5000);
       for (const batch of batches) {
         await this.createEntities(batch);
       }
@@ -48855,18 +49153,14 @@ class AgentRuntime {
     return await this.adapter.addParticipantsRoom(entityIds, roomId);
   }
   async ensureWorldExists({ id, name, messageServerId, metadata }) {
-    const world = await this.getWorld(id);
-    if (!world) {
-      this.logger.debug({ src: "agent", agentId: this.agentId, worldId: id, name, messageServerId }, "Creating world");
-      await this.adapter.createWorld({
-        id,
-        name,
-        agentId: this.agentId,
-        messageServerId,
-        metadata
-      });
-      this.logger.debug({ src: "agent", agentId: this.agentId, worldId: id, messageServerId }, "World created");
-    }
+    this.logger.debug({ src: "agent", agentId: this.agentId, worldId: id, name, messageServerId }, "Ensuring world exists");
+    await this.adapter.createWorld({
+      id,
+      name,
+      agentId: this.agentId,
+      messageServerId,
+      metadata
+    });
   }
   async ensureRoomExists({
     id,
@@ -49404,16 +49698,18 @@ ${input}`;
     if (!this.adapter) {
       throw new Error("Database adapter not initialized before ensureEmbeddingDimension");
     }
-    const model = this.getModel(ModelType.TEXT_EMBEDDING);
-    if (!model) {
+    if (!this.getModel(ModelType.TEXT_EMBEDDING)) {
       throw new Error("No TEXT_EMBEDDING model registered");
     }
-    const embedding = await this.useModel(ModelType.TEXT_EMBEDDING, { text: "" });
-    if (!embedding || !embedding.length) {
-      throw new Error("Invalid embedding received");
+    const providedDimension = this.getSetting("EMBEDDING_DIMENSION");
+    const parsedDimension = Number(providedDimension);
+    const useProvidedDimension = parsedDimension > 0;
+    const dimension = useProvidedDimension ? parsedDimension : (await this.useModel(ModelType.TEXT_EMBEDDING, { text: "" }))?.length;
+    if (!dimension) {
+      throw new Error("Invalid embedding dimension");
     }
-    await this.adapter.ensureEmbeddingDimension(embedding.length);
-    this.logger.debug({ src: "agent", agentId: this.agentId, dimension: embedding.length }, "Embedding dimension set");
+    await this.adapter.ensureEmbeddingDimension(dimension);
+    this.logger.debug({ src: "agent", agentId: this.agentId, dimension }, useProvidedDimension ? "Embedding dimension set from config" : "Embedding dimension set via API call");
   }
   registerTaskWorker(taskHandler) {
     if (this.taskWorkers.has(taskHandler.name)) {
@@ -49511,6 +49807,14 @@ ${input}`;
     }
     return await this.createEntities([entity]);
   }
+  async ensureEntity(entity) {
+    if (!entity.id)
+      return null;
+    const created = await this.createEntity(entity);
+    if (!created)
+      return null;
+    return entity;
+  }
   async createEntities(entities) {
     entities.forEach((e) => {
       e.agentId = this.agentId;
@@ -51265,5 +51569,5 @@ export {
   ActionStreamFilter
 };
 
-//# debugId=B5101D8C783AC7F864756E2164756E21
+//# debugId=9E4B3437FAC39D4E64756E2164756E21
 //# sourceMappingURL=index.node.js.map