@elizaos/core 1.7.1-alpha.2 → 1.7.1-alpha.3

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);
@@ -21746,7 +21746,7 @@ var require_parse_asn1 = __commonJS((exports, module) => {
 
 // ../../node_modules/public-encrypt/mgf.js
 var require_mgf = __commonJS((exports, module) => {
-  var createHash = require_create_hash();
+  var createHash2 = require_create_hash();
   var Buffer2 = require_safe_buffer().Buffer;
   module.exports = function(seed, len) {
     var t = Buffer2.alloc(0);
@@ -21754,7 +21754,7 @@ var require_mgf = __commonJS((exports, module) => {
     var c;
     while (t.length < len) {
       c = i2ops(i++);
-      t = Buffer2.concat([t, createHash("sha1").update(seed).update(c).digest()]);
+      t = Buffer2.concat([t, createHash2("sha1").update(seed).update(c).digest()]);
     }
     return t.slice(0, len);
   };
@@ -24739,7 +24739,7 @@ var require_browserify_rsa = __commonJS((exports, module) => {
 var require_publicEncrypt = __commonJS((exports, module) => {
   var parseKeys = require_parse_asn1();
   var randomBytes2 = require_randombytes();
-  var createHash = require_create_hash();
+  var createHash2 = require_create_hash();
   var mgf = require_mgf();
   var xor = require_xor();
   var BN = require_bn();
@@ -24778,7 +24778,7 @@ var require_publicEncrypt = __commonJS((exports, module) => {
   function oaep(key, msg) {
     var k = key.modulus.byteLength();
     var mLen = msg.length;
-    var iHash = createHash("sha1").update(Buffer2.alloc(0)).digest();
+    var iHash = createHash2("sha1").update(Buffer2.alloc(0)).digest();
     var hLen = iHash.length;
     var hLen2 = 2 * hLen;
     if (mLen > k - hLen2 - 2) {
@@ -24832,7 +24832,7 @@ var require_privateDecrypt = __commonJS((exports, module) => {
   var xor = require_xor();
   var BN = require_bn();
   var crt = require_browserify_rsa();
-  var createHash = require_create_hash();
+  var createHash2 = require_create_hash();
   var withPublic = require_withPublic();
   var Buffer2 = require_safe_buffer().Buffer;
   module.exports = function privateDecrypt(privateKey, enc, reverse) {
@@ -24869,7 +24869,7 @@ var require_privateDecrypt = __commonJS((exports, module) => {
   };
   function oaep(key, msg) {
     var k = key.modulus.byteLength();
-    var iHash = createHash("sha1").update(Buffer2.alloc(0)).digest();
+    var iHash = createHash2("sha1").update(Buffer2.alloc(0)).digest();
     var hLen = iHash.length;
     if (msg[0] !== 0) {
       throw new Error("decryption error");
@@ -27980,6 +27980,9 @@ var _getFetchImplementation = (debug) => {
 var getDefaultProjectName = () => {
   return getLangSmithEnvironmentVariable("PROJECT") ?? getEnvironmentVariable2("LANGCHAIN_SESSION") ?? "default";
 };
+// ../../node_modules/langsmith/dist/utils/_uuid.js
+import { createHash } from "crypto";
+
 // ../../node_modules/langsmith/dist/utils/warn.js
 var warnedMessages = {};
 function warnOnce(message) {
@@ -28002,8 +28005,46 @@ function uuid7FromTime(timestamp) {
   const msecs = typeof timestamp === "string" ? Date.parse(timestamp) : timestamp;
   return v72({ msecs, seq: 0 });
 }
+function getUuidVersion(uuidStr) {
+  if (!UUID_REGEX.test(uuidStr)) {
+    return null;
+  }
+  const versionChar = uuidStr[14];
+  return parseInt(versionChar, 16);
+}
+function uuidToBytes(uuidStr) {
+  const hex = uuidStr.replace(/-/g, "");
+  return Buffer.from(hex, "hex");
+}
+function bytesToUuid(bytes) {
+  const hex = bytes.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function uuid7Deterministic(originalId, key) {
+  const hashInput = `${originalId}:${key}`;
+  const h = createHash("sha256").update(hashInput).digest();
+  const b = Buffer.alloc(16);
+  const version3 = getUuidVersion(originalId);
+  if (version3 === 7) {
+    const originalBytes = uuidToBytes(originalId);
+    originalBytes.copy(b, 0, 0, 6);
+  } else {
+    const msecs = Date.now();
+    b[0] = msecs / 1099511627776 & 255;
+    b[1] = msecs / 4294967296 & 255;
+    b[2] = msecs / 16777216 & 255;
+    b[3] = msecs / 65536 & 255;
+    b[4] = msecs / 256 & 255;
+    b[5] = msecs & 255;
+  }
+  b[6] = 112 | h[0] & 15;
+  b[7] = h[1];
+  b[8] = 128 | h[2] & 63;
+  h.copy(b, 9, 3, 10);
+  return bytesToUuid(b);
+}
 // ../../node_modules/langsmith/dist/index.js
-var __version__ = "0.4.2";
+var __version__ = "0.4.3";
 
 // ../../node_modules/langsmith/dist/utils/env.js
 var globalEnv;
@@ -29041,6 +29082,220 @@ function isConflictingEndpointsError(err) {
   return typeof err === "object" && err !== null && err.code === ERR_CONFLICTING_ENDPOINTS;
 }
 
+// ../../node_modules/langsmith/dist/utils/prompts_cache.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+function isStale(entry, ttlSeconds) {
+  if (ttlSeconds === null) {
+    return false;
+  }
+  const ageMs = Date.now() - entry.createdAt;
+  return ageMs > ttlSeconds * 1000;
+}
+
+class PromptCache {
+  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 dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const entries = {};
+    for (const [key, entry] of this.cache.entries()) {
+      entries[key] = entry.value;
+    }
+    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;
+    }
+  }
+  load(filePath) {
+    if (!fs.existsSync(filePath)) {
+      return 0;
+    }
+    let data;
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      data = JSON.parse(content);
+    } catch {
+      return 0;
+    }
+    const entries = data.entries ?? {};
+    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/utils/fast-safe-stringify/index.js
 var LIMIT_REPLACE_NODE = "[...]";
 var CIRCULAR_REPLACE_NODE = { result: "[Circular]" };
@@ -29531,6 +29786,12 @@ class Client {
       writable: true,
       value: undefined
     });
+    Object.defineProperty(this, "_promptCache", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
     Object.defineProperty(this, "multipartStreamingDisabled", {
       enumerable: true,
       configurable: true,
@@ -29596,6 +29857,19 @@ class Client {
       this.langSmithToOTELTranslator = new LangSmithToOTELTranslator;
     }
     this.cachedLSEnvVarsForMetadata = getLangSmithEnvVarsMetadata();
+    const cacheEnabled = config.promptCacheEnabled ?? getLangSmithEnvironmentVariable("PROMPT_CACHE_ENABLED") === "true";
+    if (cacheEnabled) {
+      this._promptCache = new PromptCache({
+        maxSize: config.promptCacheMaxSize ?? parseInt(getLangSmithEnvironmentVariable("PROMPT_CACHE_MAX_SIZE") ?? "100", 10),
+        ttlSeconds: config.promptCacheTtlSeconds ?? parseFloat(getLangSmithEnvironmentVariable("PROMPT_CACHE_TTL_SECONDS") ?? "3600"),
+        refreshIntervalSeconds: config.promptCacheRefreshIntervalSeconds ?? parseFloat(getLangSmithEnvironmentVariable("PROMPT_CACHE_REFRESH_INTERVAL_SECONDS") ?? "60"),
+        fetchFunc: this._makeFetchPromptFunc()
+      });
+      const cachePath = config.promptCachePath ?? getLangSmithEnvironmentVariable("PROMPT_CACHE_PATH");
+      if (cachePath) {
+        this._promptCache.load(cachePath);
+      }
+    }
   }
   static getDefaultClientConfig() {
     const apiKey = getLangSmithEnvironmentVariable("API_KEY");
@@ -29648,9 +29922,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 +29960,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 +29970,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 +29993,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 +30007,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 +30855,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 +30872,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 +31182,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 +31218,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 +31233,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 +31396,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 +31449,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 +31481,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 +31530,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 +31540,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 +31712,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 +31796,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 +32035,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 +32709,18 @@ 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}`;
+  }
+  _makeFetchPromptFunc() {
+    return async (key) => {
+      const includeModel = key.endsWith(":with_model");
+      const identifier = includeModel ? key.slice(0, -11) : key;
+      return this._fetchPromptFromApi(identifier, { includeModel });
+    };
+  }
+  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 +32741,23 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
       examples: result.examples
     };
   }
+  async pullPromptCommit(promptIdentifier, options) {
+    if (!options?.skipCache && this._promptCache) {
+      const cacheKey = this._getPromptCacheKey(promptIdentifier, options?.includeModel);
+      const cached = this._promptCache.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+      const result = await this._fetchPromptFromApi(promptIdentifier, options);
+      this._promptCache.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 +32839,14 @@ Message: ${Array.isArray(result.detail) ? result.detail.join(`
       throw new Error(`Invalid public ${kind} URL or token: ${urlOrToken}`);
     }
   }
+  get promptCache() {
+    return this._promptCache;
+  }
+  cleanup() {
+    if (this._promptCache) {
+      this._promptCache.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.");
@@ -32841,6 +33148,12 @@ class RunTree {
       writable: true,
       value: undefined
     });
+    Object.defineProperty(this, "_awaitInputsOnPost", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: undefined
+    });
     if (isRunTree(originalConfig)) {
       Object.assign(this, { ...originalConfig });
       return;
@@ -33103,23 +33416,23 @@ class RunTree {
       }
     }
     const oldId = baseRun.id;
-    const newId = v52(`${oldId}:${projectName}`, UUID_NAMESPACE_DNS);
+    const newId = uuid7Deterministic(oldId, projectName);
     let newTraceId;
     if (baseRun.trace_id) {
-      newTraceId = v52(`${baseRun.trace_id}:${projectName}`, UUID_NAMESPACE_DNS);
+      newTraceId = uuid7Deterministic(baseRun.trace_id, projectName);
     } else {
       newTraceId = newId;
     }
     let newParentId;
     if (baseRun.parent_run_id) {
-      newParentId = v52(`${baseRun.parent_run_id}:${projectName}`, UUID_NAMESPACE_DNS);
+      newParentId = uuid7Deterministic(baseRun.parent_run_id, projectName);
     }
     let newDottedOrder;
     if (baseRun.dotted_order) {
       const segs = baseRun.dotted_order.split(".");
       const remappedSegs = segs.map((seg) => {
         const segId = seg.slice(-TIMESTAMP_LENGTH);
-        const remappedId = v52(`${segId}:${projectName}`, UUID_NAMESPACE_DNS);
+        const remappedId = uuid7Deterministic(segId, projectName);
         return seg.slice(0, -TIMESTAMP_LENGTH) + remappedId;
       });
       newDottedOrder = remappedSegs.join(".");
@@ -33134,6 +33447,9 @@ class RunTree {
     };
   }
   async postRun(excludeChildRuns = true) {
+    if (this._awaitInputsOnPost) {
+      this.inputs = await this.inputs;
+    }
     try {
       const runtimeEnv = getRuntimeEnvironment2();
       if (this.replicas && this.replicas.length > 0) {
@@ -35252,13 +35568,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)
@@ -35474,8 +35790,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;
@@ -39954,10 +40270,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";
@@ -42055,17 +42371,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;
     }
@@ -44787,7 +45103,7 @@ function stringToUuid(target) {
   const bytes = digest.slice(0, 16);
   bytes[8] = bytes[8] & 63 | 128;
   bytes[6] = bytes[6] & 15 | 0;
-  return bytesToUuid(bytes);
+  return bytesToUuid2(bytes);
 }
 async function prewarmUuidCache(values) {
   if (!checkWebCrypto())
@@ -44925,7 +45241,7 @@ function utf8Encode(str) {
   }
   return new Uint8Array(utf8);
 }
-function bytesToUuid(bytes) {
+function bytesToUuid2(bytes) {
   const hex = [];
   for (let i = 0;i < bytes.length; i++) {
     const h = bytes[i].toString(16).padStart(2, "0");
@@ -44945,9 +45261,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";
@@ -45464,8 +45780,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(/\/$/, "");
 };
@@ -49130,6 +49446,41 @@ class AgentRuntime {
       modelSettings.presencePenalty = presencePenalty;
     return Object.keys(modelSettings).length > 0 ? modelSettings : null;
   }
+  logModelCall(modelType, modelKey, params, promptContent, elapsedTime, provider, response) {
+    if (modelKey !== ModelType.TEXT_EMBEDDING && promptContent) {
+      if (this.currentActionContext) {
+        this.currentActionContext.prompts.push({
+          modelType: modelKey,
+          prompt: promptContent,
+          timestamp: Date.now()
+        });
+      }
+    }
+    this.adapter.log({
+      entityId: this.agentId,
+      roomId: this.currentRoomId ?? this.agentId,
+      body: {
+        modelType,
+        modelKey,
+        params: {
+          ...typeof params === "object" && !Array.isArray(params) && params ? params : {},
+          prompt: promptContent
+        },
+        prompt: promptContent,
+        systemPrompt: this.character?.system || null,
+        runId: this.getCurrentRunId(),
+        timestamp: Date.now(),
+        executionTime: elapsedTime,
+        provider: provider || this.models.get(modelKey)?.[0]?.provider || "unknown",
+        actionContext: this.currentActionContext ? {
+          actionName: this.currentActionContext.actionName,
+          actionId: this.currentActionContext.actionId
+        } : undefined,
+        response: Array.isArray(response) && response.every((x) => typeof x === "number") ? "[array]" : response
+      },
+      type: `useModel:${modelKey}`
+    });
+  }
   async useModel(modelType, params, provider) {
     const modelKey = typeof modelType === "string" ? modelType : ModelType[modelType];
     const paramsObj = params;
@@ -49224,6 +49575,7 @@ class AgentRuntime {
         duration: Number(elapsedTime2.toFixed(2)),
         streaming: true
       }, "Model output (stream with callback complete)");
+      this.logModelCall(modelType, modelKey, params, promptContent, elapsedTime2, provider, fullText);
       return fullText;
     }
     const elapsedTime = (typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now()) - startTime;
@@ -49233,39 +49585,7 @@ class AgentRuntime {
       model: modelKey,
       duration: Number(elapsedTime.toFixed(2))
     }, "Model output");
-    if (modelKey !== ModelType.TEXT_EMBEDDING && promptContent) {
-      if (this.currentActionContext) {
-        this.currentActionContext.prompts.push({
-          modelType: modelKey,
-          prompt: promptContent,
-          timestamp: Date.now()
-        });
-      }
-    }
-    this.adapter.log({
-      entityId: this.agentId,
-      roomId: this.currentRoomId ?? this.agentId,
-      body: {
-        modelType,
-        modelKey,
-        params: {
-          ...typeof params === "object" && !Array.isArray(params) && params ? params : {},
-          prompt: promptContent
-        },
-        prompt: promptContent,
-        systemPrompt: this.character?.system || null,
-        runId: this.getCurrentRunId(),
-        timestamp: Date.now(),
-        executionTime: elapsedTime,
-        provider: provider || this.models.get(modelKey)?.[0]?.provider || "unknown",
-        actionContext: this.currentActionContext ? {
-          actionName: this.currentActionContext.actionName,
-          actionId: this.currentActionContext.actionId
-        } : undefined,
-        response: Array.isArray(response) && response.every((x) => typeof x === "number") ? "[array]" : response
-      },
-      type: `useModel:${modelKey}`
-    });
+    this.logModelCall(modelType, modelKey, params, promptContent, elapsedTime, provider, response);
     return response;
   }
   async generateText(input, options) {
@@ -49878,7 +50198,7 @@ function getCryptoModule() {
   }
   return require_crypto_browserify();
 }
-function createHash(algorithm) {
+function createHash2(algorithm) {
   const crypto2 = getCryptoModule();
   const hash = crypto2.createHash(algorithm);
   return {
@@ -49987,7 +50307,7 @@ function encryptStringValue(value, salt) {
       }
     } catch {}
   }
-  const key = createHash("sha256").update(salt).digest().slice(0, 32);
+  const key = createHash2("sha256").update(salt).digest().slice(0, 32);
   const iv = BufferUtils.randomBytes(16);
   const cipher = createCipheriv("aes-256-cbc", key, iv);
   let encrypted = cipher.update(value, "utf8", "hex");
@@ -50005,7 +50325,7 @@ function decryptStringValue(value, salt) {
     if (iv.length !== 16) {
       return value;
     }
-    const key = createHash("sha256").update(salt).digest().slice(0, 32);
+    const key = createHash2("sha256").update(salt).digest().slice(0, 32);
     const decipher = createDecipheriv("aes-256-cbc", key, iv);
     let decrypted = decipher.update(encrypted, "hex", "utf8");
     decrypted += decipher.final("utf8");
@@ -51214,5 +51534,5 @@ export {
   ActionStreamFilter
 };
 
-//# debugId=108305E81D5AB81564756E2164756E21
+//# debugId=0EA8CF3BFF9CF58964756E2164756E21
 //# sourceMappingURL=index.node.js.map