@t2000/engine 1.14.0 → 1.15.1

package/dist/index.d.ts

@@ -1715,7 +1715,7 @@ declare function bundleShortestTtl(toolUseIds: string[], toolNamesById: Record<s
 declare const REGENERATABLE_READ_TOOLS: ReadonlySet<string>;
 
 /**
- * [Phase 0 → Phase 2 / SPEC 13] Maximum number of writes per atomic bundle.
+ * [Phase 0 → Phase 3a / SPEC 13] Maximum number of writes per atomic bundle.
  *
  * **History.**
  *  - Pre-Phase-0: 5 (F14-fix-2, 2026-05-03 morning).
@@ -1730,31 +1730,35 @@ declare const REGENERATABLE_READ_TOOLS: ReadonlySet<string>;
  *    `composeTx` orchestration loop) but didn't widen the cap. The
  *    primitive is what makes Phase 2's raise to 3 possible — without it,
  *    every additional step is another wallet-fetch race.
- *  - Phase 2 (1.14.0, this version): cap raised to 3. Composition rule
- *    is strict-adjacency: every (step[i], step[i+1]) pair must be in
- *    `VALID_PAIRS`. No new pairs added — Phase 2 is purely the cap raise
- *    + adjacency-loop validation. The chain-mode population loop already
- *    runs over every `(i, i+1)` since 1.13.0, so 3-op atomic bundles
- *    like `withdraw → swap → send` thread two coin handles end-to-end
- *    in one PTB.
- *
- * **Why strict adjacency?** Every consecutive pair must be whitelisted
- * even if the consumer doesn't chain (no `inputCoinFromStep`). This
- * keeps the validator simple and matches the spec's Phase 2 model. The
- * looser DAG-aware variant (where non-chained adjacent steps can be
- * any tool combo) is a Phase 3 follow-up — defer until we see real
- * production flows that need it.
- *
- * **Phase 3+:** `swap_execute → swap_execute` (Demo 1 unlock) + DAG-aware
- * validator + cap raise to 4. SPEC 13 §"Phase 3" / §"Phase 5" tracks
- * these. Don't pre-emptively raise this constant past 3 without those
- * landing.
+ *  - Phase 2 (1.14.0): cap raised to 3. Composition rule was strict-
+ *    adjacency: every (step[i], step[i+1]) pair must be in `VALID_PAIRS`.
+ *    Strict adjacency rejected DAG shapes (`swap → save → send` —
+ *    last pair `save→send` not in whitelist even though step 3 doesn't
+ *    chain from step 2; it pulls a fresh wallet coin).
+ *  - **Phase 3a (1.15.0, this version): cap raised to 4. Composition rule
+ *    relaxed to DAG-aware: only pairs that actually chain via
+ *    `inputCoinFromStep` need whitelist checking. Standalone steps
+ *    interleaved between chained steps run wallet-mode independently
+ *    inside the same atomic PTB.** This unlocks Demo 1 ("swap 10% to
+ *    SUI, save 50% as USDsui, send $100 to Mom" — 4-op DAG with one
+ *    chain at step 1→2, three standalone wallet-mode steps).
+ *
+ * **DAG-aware semantics.** Pre-3a: every adjacent pair gates the entire
+ * bundle. Phase 3a+: each (i, i+1) pair contributes IF a chain is wired
+ * (via `shouldChainCoin`). Non-chained pairs are independent — they
+ * each pre-fetch their own coin from the wallet inside the PTB. Atomic
+ * settlement at the PTB level holds either way.
+ *
+ * **Phase 3b (deferred):** `swap_execute → swap_execute` whitelist add
+ * for explicit multi-hop swap chains (rare; flag-gated when shipped).
+ * **Phase 5+:** cap > 4 once production telemetry confirms zero edge-
+ * case revert rate at cap=4.
  *
  * Hosts importing this constant for system-prompt construction get the
  * current cap automatically. Bumping the cap is a one-line change here
  * that propagates to prompts via the import.
  */
-declare const MAX_BUNDLE_OPS = 3;
+declare const MAX_BUNDLE_OPS = 4;
 /**
  * [Phase 0 / SPEC 13] Whitelisted (producer, consumer) pairs for atomic
  * bundling. Every key has the shape `${producer}->${consumer}`. Bundles

package/dist/index.js

@@ -3647,26 +3647,35 @@ var swapExecuteTool = buildTool({
   },
   async call(input, context) {
     const agent = requireAgent(context);
-    const result = await agent.swap({
-      from: input.from,
-      to: input.to,
-      amount: input.amount,
-      byAmountIn: input.byAmountIn,
-      slippage: input.slippage
-    });
-    return {
-      data: {
-        tx: result.tx,
-        fromToken: result.fromToken,
-        toToken: result.toToken,
-        fromAmount: result.fromAmount,
-        toAmount: result.toAmount,
-        priceImpact: result.priceImpact,
-        route: result.route,
-        gasCost: result.gasCost
-      },
-      displayText: `Swapped ${result.fromAmount} ${result.fromToken} for ${result.toAmount.toFixed(4)} ${result.toToken} (tx: ${result.tx.slice(0, 8)}...)`
-    };
+    const sink = getTelemetrySink();
+    const start = Date.now();
+    try {
+      const result = await agent.swap({
+        from: input.from,
+        to: input.to,
+        amount: input.amount,
+        byAmountIn: input.byAmountIn,
+        slippage: input.slippage
+      });
+      sink.histogram("cetus.swap_execute_total_ms", Date.now() - start);
+      sink.counter("cetus.swap_execute_count", { outcome: "success" });
+      return {
+        data: {
+          tx: result.tx,
+          fromToken: result.fromToken,
+          toToken: result.toToken,
+          fromAmount: result.fromAmount,
+          toAmount: result.toAmount,
+          priceImpact: result.priceImpact,
+          route: result.route,
+          gasCost: result.gasCost
+        },
+        displayText: `Swapped ${result.fromAmount} ${result.fromToken} for ${result.toAmount.toFixed(4)} ${result.toToken} (tx: ${result.tx.slice(0, 8)}...)`
+      };
+    } catch (err) {
+      sink.counter("cetus.swap_execute_count", { outcome: "error" });
+      throw err;
+    }
   }
 });
 var swapQuoteTool = buildTool({
@@ -3691,17 +3700,26 @@ var swapQuoteTool = buildTool({
   isReadOnly: true,
   async call(input, context) {
     const walletAddress = context.agent ? context.agent.address() : getWalletAddress(context);
-    const result = await getSwapQuote({
-      walletAddress,
-      from: input.from,
-      to: input.to,
-      amount: input.amount,
-      byAmountIn: input.byAmountIn
-    });
-    return {
-      data: result,
-      displayText: `${result.fromAmount} ${result.fromToken} \u2192 ${result.toAmount.toFixed(4)} ${result.toToken} (impact: ${(result.priceImpact * 100).toFixed(2)}%, via ${result.route})`
-    };
+    const sink = getTelemetrySink();
+    const start = Date.now();
+    try {
+      const result = await getSwapQuote({
+        walletAddress,
+        from: input.from,
+        to: input.to,
+        amount: input.amount,
+        byAmountIn: input.byAmountIn
+      });
+      sink.histogram("cetus.find_route_ms", Date.now() - start);
+      sink.counter("cetus.find_route_count", { outcome: "success" });
+      return {
+        data: result,
+        displayText: `${result.fromAmount} ${result.fromToken} \u2192 ${result.toAmount.toFixed(4)} ${result.toToken} (impact: ${(result.priceImpact * 100).toFixed(2)}%, via ${result.route})`
+      };
+    } catch (err) {
+      sink.counter("cetus.find_route_count", { outcome: "error" });
+      throw err;
+    }
   }
 });
 var voloStakeTool = buildTool({
@@ -6737,7 +6755,7 @@ var REGENERATABLE_READ_TOOLS = /* @__PURE__ */ new Set([
 ]);
 
 // src/compose-bundle.ts
-var MAX_BUNDLE_OPS = 3;
+var MAX_BUNDLE_OPS = 4;
 var VALID_PAIRS = /* @__PURE__ */ new Set([
   "swap_execute->send_transfer",
   "swap_execute->save_deposit",
@@ -7885,7 +7903,7 @@ ${recipeCtx}`;
       }
       if (guardPassedWrites.length > MAX_BUNDLE_OPS) {
         const cappedError = {
-          error: `Atomic bundles are capped at ${MAX_BUNDLE_OPS} ops in Phase 0. You attempted ${guardPassedWrites.length}. Execute these as ${guardPassedWrites.length} sequential single-write transactions: tell the user "I'll do this in ${guardPassedWrites.length} steps", then emit only the FIRST write. After it lands and the user confirms each step, emit the next.`,
+          error: `Atomic bundles are capped at ${MAX_BUNDLE_OPS} ops. You attempted ${guardPassedWrites.length}. Execute these as ${guardPassedWrites.length} sequential single-write transactions: tell the user "I'll do this in ${guardPassedWrites.length} steps", then emit only the FIRST write. After it lands and the user confirms each step, emit the next.`,
           _gate: "max_bundle_ops"
         };
         for (const write of guardPassedWrites) {
@@ -7916,50 +7934,6 @@ ${recipeCtx}`;
         const turnIndex = this.messages.filter((m) => m.role === "assistant").length;
         this.turnPaused = true;
         if (allBundleable) {
-          if (guardPassedWrites.length >= 2) {
-            let badPair = null;
-            for (let i = 0; i < guardPassedWrites.length - 1; i++) {
-              const producer = guardPassedWrites[i].call.name;
-              const consumer = guardPassedWrites[i + 1].call.name;
-              const check = checkValidPair(producer, consumer);
-              if (!check.ok) {
-                badPair = check;
-                break;
-              }
-            }
-            if (badPair !== null) {
-              const N = guardPassedWrites.length;
-              const stepsPhrase = N === 2 ? "two steps" : `${N} steps`;
-              const pairError = {
-                error: `Bundle pair '${badPair.pair}' is not in the chaining whitelist. Whitelisted pairs: ${[...VALID_PAIRS].join(", ")}. Run these ${N} writes sequentially: tell the user "I'll do this in ${stepsPhrase}", emit only the first write, then the next after it lands and confirms.`,
-                _gate: "pair_not_whitelisted"
-              };
-              for (const write of guardPassedWrites) {
-                yield {
-                  type: "tool_result",
-                  toolName: write.call.name,
-                  toolUseId: write.call.id,
-                  result: pairError,
-                  isError: true
-                };
-                toolResultBlocks.push({
-                  type: "tool_result",
-                  toolUseId: write.call.id,
-                  content: JSON.stringify(pairError),
-                  isError: true
-                });
-              }
-              this.turnPaused = false;
-              this.messages.push({ role: "assistant", content: acc.assistantBlocks });
-              this.messages.push({ role: "user", content: toolResultBlocks });
-              getTelemetrySink().counter("engine.turn_outcome", {
-                entry: freshPrompt !== null ? "submit" : "resume",
-                outcome: "pair_not_whitelisted_continue",
-                pair: badPair.pair
-              });
-              continue;
-            }
-          }
           const completedResults = toolResultBlocks.map((b) => ({
             toolUseId: b.toolUseId,
             content: b.content,