@t2000/engine 1.25.0 → 1.25.2

package/dist/index.js

@@ -3771,6 +3771,34 @@ var swapQuoteTool = buildTool({
     required: ["from", "to", "amount"]
   },
   isReadOnly: true,
+  // [SPEC 20.2 / D-1 (a) follow-on, 2026-05-10] Quote results MUST NOT be
+  // cross-turn deduped by microcompact. Every call legitimately produces a
+  // new result — pool reserves move per block, slippage windows update, the
+  // best route can shift if liquidity moves, and the result's `discoveredAt`
+  // timestamp is different per call by definition.
+  //
+  // Pre-fix: microcompact's default `cacheable: true` replaced the second
+  // identical-input swap_quote tool_result with a `[Same result as call #N
+  // — swap_quote with identical inputs. Result unchanged.]` placeholder.
+  // The placeholder lied — the route and `discoveredAt` had legitimately
+  // updated. Audric's bundle fast-path (which reads quote results from the
+  // persisted ledger to thread `step.cetusRoute`) lost the fresh route and
+  // had to fall back to whichever earlier same-input call WAS preserved
+  // (the "first-seen" anchor, often >30s old → rejected by audric's
+  // `isCetusRouteFresh` 30s gate → fast path missed → bundle paid full
+  // ~400-500ms `findSwapRoute()` round-trip at confirm time).
+  //
+  // Production smoke trace (2026-05-10, session s_1778362657811_c0ed9009a5fb):
+  //   T0     swap_quote(USDC,SUI,0.5)              → route X discovered
+  //   T0+34s swap_quote(USDC,SUI,0.5) [bundle]     → route Y discovered (FRESH)
+  //   T0+50s "Confirm" → fast-path walks history   → walker sees placeholder
+  //                                                   on route Y, falls back
+  //                                                   to route X (52s old)
+  //   T0+52s prepare → cetusRoute STALE → fallback → no perf win
+  //
+  // With `cacheable: false`: route Y stays as full content in the ledger,
+  // walker finds it (~18s old), passes the freshness gate, fast path fires.
+  cacheable: false,
   async call(input, context) {
     const walletAddress = context.agent ? context.agent.address() : getWalletAddress(context);
     const sink = getTelemetrySink();
@@ -7640,7 +7668,7 @@ var QueryEngine = class {
       })),
       ...writeResultBlocks
     ];
-    const canonicalRouteText = response.approved ? buildCanonicalRouteText(action) : null;
+    const canonicalRouteText = response.approved ? buildCanonicalRouteText(action, response) : null;
     if (canonicalRouteText) {
       allResults.push({ type: "text", text: canonicalRouteText });
     }
@@ -9000,16 +9028,33 @@ ${recipeCtx}`;
     }
   }
 };
-function buildCanonicalRouteText(action) {
+function buildCanonicalRouteText(action, response) {
+  const failedToolUseIds = /* @__PURE__ */ new Set();
+  if (Array.isArray(action.steps) && action.steps.length > 0) {
+    const stepResultByToolUseId = new Map(
+      (response.stepResults ?? []).map((sr) => [sr.toolUseId, sr])
+    );
+    for (const step of action.steps) {
+      const sr = stepResultByToolUseId.get(step.toolUseId);
+      if (!sr || sr.isError === true) {
+        failedToolUseIds.add(step.toolUseId);
+      }
+    }
+  } else if (isExecutionResultFailure(response.executionResult)) {
+    failedToolUseIds.add(action.toolUseId);
+  }
   const swaps = [];
   if (Array.isArray(action.steps) && action.steps.length > 0) {
     for (const step of action.steps) {
       if (step.toolName === "swap_execute" && step.cetusRoute) {
+        if (failedToolUseIds.has(step.toolUseId)) continue;
         swaps.push({ input: step.input, cetusRoute: step.cetusRoute });
       }
     }
   } else if (action.toolName === "swap_execute" && action.cetusRoute) {
-    swaps.push({ input: action.input, cetusRoute: action.cetusRoute });
+    if (!failedToolUseIds.has(action.toolUseId)) {
+      swaps.push({ input: action.input, cetusRoute: action.cetusRoute });
+    }
   }
   if (swaps.length === 0) return null;
   const blocks = swaps.map(({ input, cetusRoute }) => {
@@ -9029,6 +9074,24 @@ function buildCanonicalRouteText(action) {
   });
   return blocks.join("\n\n");
 }
+function isExecutionResultFailure(executionResult) {
+  if (executionResult === null || executionResult === void 0) return false;
+  if (typeof executionResult !== "object") return false;
+  const er = executionResult;
+  if (er.success === false) return true;
+  if (typeof er.error === "string" && er.error.length > 0) return true;
+  if (er._bundleReverted === true) return true;
+  if (er._sessionExpired === true) return true;
+  if (er._txReverted === true) return true;
+  if (er.data && typeof er.data === "object") {
+    const d = er.data;
+    if (typeof d.error === "string" && d.error.length > 0) return true;
+    if (d._bundleReverted === true) return true;
+    if (d._sessionExpired === true) return true;
+    if (d._txReverted === true) return true;
+  }
+  return false;
+}
 function isCorruptHistoryError(err) {
   const msg = err instanceof Error ? err.message : String(err);
   return msg.includes("tool_use") && msg.includes("tool_result") || msg.includes("roles must alternate") || msg.includes("400") && msg.includes("invalid_request_error");