@t2000/engine 1.24.8 → 1.24.10

package/dist/index.js

@@ -5786,6 +5786,120 @@ Only offer to execute actions you have tools for. If you retrieved a quote, data
 - Cap: at most ONE proactive block per turn.
 - Skip proactive blocks when nothing notable changed since the last turn, when the user is mid-flow on something else, or when you'd just be restating the financial-context block. Quality over quantity \u2014 a block ignored is worse than no block.`;
 
+// src/post-write-poll.ts
+async function pollForIndexerCatchup(options) {
+  const { suiRpcUrl, address, ceilingMs, pollIntervalMs, signal } = options;
+  const start = Date.now();
+  if (!suiRpcUrl) {
+    await sleepWithFallback(ceilingMs, signal);
+    return {
+      outcome: "fallback_no_rpc",
+      attempts: 0,
+      resolvedAtMs: Date.now() - start
+    };
+  }
+  if (!address) {
+    await sleepWithFallback(ceilingMs, signal);
+    return {
+      outcome: "fallback_no_address",
+      attempts: 0,
+      resolvedAtMs: Date.now() - start
+    };
+  }
+  let baseline;
+  try {
+    const coins = await fetchWalletCoins(address, suiRpcUrl);
+    baseline = new Map(
+      coins.map((c) => [c.coinType, BigInt(c.totalBalance)])
+    );
+  } catch (err) {
+    console.warn(
+      "[post-write-poll] baseline fetch failed; falling back to fixed sleep:",
+      err
+    );
+    await sleepWithFallback(ceilingMs, signal);
+    return {
+      outcome: "fallback_no_baseline",
+      attempts: 0,
+      resolvedAtMs: Date.now() - start
+    };
+  }
+  const maxAttempts = Math.max(1, Math.floor(ceilingMs / pollIntervalMs));
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    if (signal.aborted) {
+      return {
+        outcome: "aborted",
+        attempts: attempt - 1,
+        resolvedAtMs: Date.now() - start
+      };
+    }
+    await new Promise((resolve) => {
+      const t = setTimeout(resolve, pollIntervalMs);
+      signal.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(t);
+          resolve();
+        },
+        { once: true }
+      );
+    });
+    if (signal.aborted) {
+      return {
+        outcome: "aborted",
+        attempts: attempt,
+        resolvedAtMs: Date.now() - start
+      };
+    }
+    let current;
+    try {
+      const coins = await fetchWalletCoins(address, suiRpcUrl);
+      current = new Map(
+        coins.map((c) => [c.coinType, BigInt(c.totalBalance)])
+      );
+    } catch (err) {
+      console.warn(
+        `[post-write-poll] poll attempt ${attempt} failed; continuing:`,
+        err
+      );
+      continue;
+    }
+    if (balancesDiffer(baseline, current)) {
+      return {
+        outcome: "detected_change",
+        attempts: attempt,
+        resolvedAtMs: Date.now() - start
+      };
+    }
+  }
+  return {
+    outcome: "ceiling",
+    attempts: maxAttempts,
+    resolvedAtMs: Date.now() - start
+  };
+}
+function balancesDiffer(a, b) {
+  if (a.size !== b.size) return true;
+  for (const [coinType, balance] of a) {
+    if (b.get(coinType) !== balance) return true;
+  }
+  return false;
+}
+async function sleepWithFallback(ms, signal) {
+  if (signal.aborted) return;
+  await new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    signal.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(t);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
+
 // src/proactive-marker.ts
 var VALID_TYPES = /* @__PURE__ */ new Set([
   "idle_balance",
@@ -7814,6 +7928,7 @@ var QueryEngine = class {
    * the fresh tool results and narrates from them.
    */
   async *runPostWriteRefresh(action, response, signal) {
+    const totalStart = Date.now();
     const isBundle = Array.isArray(action.steps) && action.steps.length > 0;
     const refreshSet = /* @__PURE__ */ new Set();
     if (isBundle) {
@@ -7855,27 +7970,48 @@ var QueryEngine = class {
       blockvisionApiKey: this.blockvisionApiKey,
       portfolioCache: this.portfolioCache
     };
+    const cacheInvalidationStart = Date.now();
     if (this.walletAddress) {
       this.portfolioCache?.delete(this.walletAddress);
       await clearPortfolioCacheFor(this.walletAddress);
     }
-    if (!signal.aborted) {
-      await new Promise((resolve) => {
-        const t = setTimeout(resolve, 1500);
-        signal.addEventListener("abort", () => {
-          clearTimeout(t);
-          resolve();
-        }, { once: true });
-      });
-    }
+    getTelemetrySink().histogram(
+      "engine.pwr.cache_invalidation_ms",
+      Date.now() - cacheInvalidationStart,
+      { has_wallet: this.walletAddress ? "1" : "0" }
+    );
+    const sleepStart = Date.now();
+    const pollResult = await pollForIndexerCatchup({
+      suiRpcUrl: this.suiRpcUrl,
+      address: this.walletAddress,
+      ceilingMs: 1500,
+      pollIntervalMs: 250,
+      signal
+    });
+    getTelemetrySink().histogram(
+      "engine.pwr.sleep_ms",
+      Date.now() - sleepStart,
+      {
+        aborted: signal.aborted ? "1" : "0",
+        outcome: pollResult.outcome,
+        attempts: String(pollResult.attempts)
+      }
+    );
     if (signal.aborted) return;
+    const refreshStart = Date.now();
     const idStem = `pwr_${action.toolUseId.slice(-6)}`;
     const refreshes = await Promise.all(
       refreshTools.map(async (tool, idx) => {
         const id = `${idStem}_${idx}_${tool.name}`;
+        const toolStart = Date.now();
         try {
           const parsed = tool.inputSchema.safeParse({});
           if (!parsed.success) {
+            getTelemetrySink().histogram(
+              "engine.pwr.tool_ms",
+              Date.now() - toolStart,
+              { tool: tool.name, outcome: "invalid_input" }
+            );
             return {
               tool,
               id,
@@ -7888,6 +8024,11 @@ var QueryEngine = class {
           }
           const { context: toolCtx, readAttemptCount } = withRetryStats(context);
           const result = await tool.call(parsed.data, toolCtx);
+          getTelemetrySink().histogram(
+            "engine.pwr.tool_ms",
+            Date.now() - toolStart,
+            { tool: tool.name, outcome: "success" }
+          );
           return {
             tool,
             id,
@@ -7896,6 +8037,11 @@ var QueryEngine = class {
             attemptCount: readAttemptCount()
           };
         } catch (err) {
+          getTelemetrySink().histogram(
+            "engine.pwr.tool_ms",
+            Date.now() - toolStart,
+            { tool: tool.name, outcome: "error" }
+          );
           return {
             tool,
             id,
@@ -7908,6 +8054,14 @@ var QueryEngine = class {
         }
       })
     );
+    getTelemetrySink().histogram(
+      "engine.pwr.refresh_total_ms",
+      Date.now() - refreshStart,
+      {
+        tool_count: String(refreshTools.length),
+        is_bundle: isBundle ? "1" : "0"
+      }
+    );
     const refreshUses = refreshes.map((r) => ({
       type: "tool_use",
       id: r.id,
@@ -7939,6 +8093,14 @@ var QueryEngine = class {
         ...r.attemptCount !== void 0 ? { attemptCount: r.attemptCount } : {}
       };
     }
+    getTelemetrySink().histogram(
+      "engine.pwr.total_ms",
+      Date.now() - totalStart,
+      {
+        tool_count: String(refreshTools.length),
+        is_bundle: isBundle ? "1" : "0"
+      }
+    );
   }
   interrupt() {
     this.abortController?.abort();