@t2000/engine 1.24.5 → 1.24.7

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
 import { Tool as Tool$1 } from '@modelcontextprotocol/sdk/types.js';
 import * as _t2000_sdk from '@t2000/sdk';
-import { PendingReward as PendingReward$1, T2000 } from '@t2000/sdk';
+import { PendingReward as PendingReward$1, SwapQuoteResult, T2000 } from '@t2000/sdk';
 
 type ProactiveType = 'idle_balance' | 'hf_warning' | 'apy_drift' | 'goal_progress';
 interface ProactiveMarker {
@@ -2710,6 +2710,18 @@ interface MicrocompactResult extends Array<Message> {
  * later call with identical inputs gets replaced — necessary because
  * their results depend on mutable on-chain state that writes invalidate.
  *
+ * [v1.24.6 / S.122] Tools whose `flags.mutating === true` are ALSO
+ * implicitly non-cacheable. Each call to a write tool produces a NEW
+ * on-chain transaction (different digest, different balance changes, real
+ * state mutation) — replacing the second result with "[Same result as
+ * call #N — identical inputs]" lies to the LLM, which then narrates
+ * "transaction deduplicated" to the user even though the on-chain write
+ * actually settled. Surfaced during S.121 smoke testing: a second
+ * `send_transfer` with identical inputs produced a real on-chain tx but
+ * the engine narrated as if it had been skipped. Explicit `cacheable`
+ * still wins (a `cacheable: true` write would be a tool-author bug, but
+ * we don't override it), so the rule is: mutating ⇒ default `false`.
+ *
  * Returns a new array — does not mutate the input. The returned array
  * carries a `dedupedToolUseIds` property listing every tool-use ID whose
  * tool_result block was replaced with a back-reference this pass.
@@ -3411,13 +3423,7 @@ declare const mppServicesTool: Tool<{
     mode?: "summary" | "full" | undefined;
 }, Record<string, unknown>>;
 
-declare const swapExecuteTool: Tool<{
-    to: string;
-    amount: number;
-    from: string;
-    byAmountIn?: boolean | undefined;
-    slippage?: number | undefined;
-}, {
+interface SwapExecuteSuccessData {
     tx: string;
     fromToken: string;
     toToken: string;
@@ -3426,14 +3432,33 @@ declare const swapExecuteTool: Tool<{
     priceImpact: number;
     route: string;
     gasCost: number;
-}>;
+}
+type SwapExecuteToolResult = SwapExecuteSuccessData | {
+    error: string;
+    errorCode: 'ASSET_NOT_SUPPORTED' | 'SWAP_FAILED';
+    hint: string;
+    recoverable: true;
+};
+declare const swapExecuteTool: Tool<{
+    to: string;
+    amount: number;
+    from: string;
+    byAmountIn?: boolean | undefined;
+    slippage?: number | undefined;
+}, SwapExecuteToolResult>;
 
+type SwapQuoteToolResult = SwapQuoteResult | {
+    error: string;
+    errorCode: 'ASSET_NOT_SUPPORTED' | 'SWAP_FAILED';
+    hint: string;
+    recoverable: true;
+};
 declare const swapQuoteTool: Tool<{
     to: string;
     amount: number;
     from: string;
     byAmountIn?: boolean | undefined;
-}, _t2000_sdk.SwapQuoteResult>;
+}, SwapQuoteToolResult>;
 
 declare const voloStakeTool: Tool<{
     amount: number;

package/dist/index.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { ALL_NAVI_ASSETS, getDecimalsForCoinType, resolveSymbol, isInRegistry, normalizeCoinType, assertAllowedAsset, normalizeAsset, SUPPORTED_ASSETS, getSwapQuote, getPendingRewardsByAddress, resolveTokenType, extractTransferDetails, classifyTransaction } from '@t2000/sdk';
+import { ALL_NAVI_ASSETS, getDecimalsForCoinType, resolveSymbol, isInRegistry, normalizeCoinType, assertAllowedAsset, normalizeAsset, SUPPORTED_ASSETS, T2000Error, getSwapQuote, getPendingRewardsByAddress, resolveTokenType, extractTransferDetails, classifyTransaction } from '@t2000/sdk';
 import { randomUUID } from 'crypto';
 import { readdirSync, readFileSync } from 'fs';
 import { join } from 'path';
@@ -3657,6 +3657,10 @@ var mppServicesTool = buildTool({
     };
   }
 });
+var RECOVERY_HINTS = {
+  ASSET_NOT_SUPPORTED: "This token symbol is not in the standard registry. Call `navi_navi_search_tokens` with the symbol to find its full coin type, then retry `swap_execute` with the full type string.",
+  SWAP_FAILED: "No route or insufficient liquidity for this pair. Try a different amount, a different intermediate token, or check `balance_check` to confirm the source token is held."
+};
 var swapExecuteTool = buildTool({
   name: "swap_execute",
   description: 'Swap tokens on Sui via Cetus Aggregator (20+ DEXs). Supports any token pair with liquidity. Use user-friendly names (SUI, USDC, CETUS, DEEP, etc.) or full coin types. Payment Intent: composable \u2014 when paired with another composable write in the same request (e.g. "swap to USDC and save", "swap and send to Mom"), emit all calls in the same assistant turn so the engine compiles them into one atomic Payment Intent the user signs once.',
@@ -3716,10 +3720,26 @@ var swapExecuteTool = buildTool({
       };
     } catch (err) {
       sink.counter("cetus.swap_execute_count", { outcome: "error" });
+      if (err instanceof T2000Error && (err.code === "ASSET_NOT_SUPPORTED" || err.code === "SWAP_FAILED")) {
+        const hint = RECOVERY_HINTS[err.code];
+        return {
+          data: {
+            error: err.message,
+            errorCode: err.code,
+            hint,
+            recoverable: true
+          },
+          displayText: err.code === "ASSET_NOT_SUPPORTED" ? `Token "${input.from}" not in standard registry \u2014 searching for full coin type.` : `No swap route available for ${input.from} \u2192 ${input.to}.`
+        };
+      }
       throw err;
     }
   }
 });
+var RECOVERY_HINTS2 = {
+  ASSET_NOT_SUPPORTED: 'This token symbol is not in the standard registry. Call `navi_navi_search_tokens` with the symbol to find its full coin type, then retry `swap_quote` with the full type string (e.g. "0x83556...::spring_sui::SPRING_SUI").',
+  SWAP_FAILED: "No route or insufficient liquidity for this pair. Try a different amount, a different intermediate token, or check `balance_check` to confirm the source token is held."
+};
 var swapQuoteTool = buildTool({
   name: "swap_quote",
   description: "Get a swap quote without executing. Shows expected output amount, price impact, and route. Use before swap_execute to preview a trade.",
@@ -3760,6 +3780,18 @@ var swapQuoteTool = buildTool({
       };
     } catch (err) {
       sink.counter("cetus.find_route_count", { outcome: "error" });
+      if (err instanceof T2000Error && (err.code === "ASSET_NOT_SUPPORTED" || err.code === "SWAP_FAILED")) {
+        const hint = RECOVERY_HINTS2[err.code];
+        return {
+          data: {
+            error: err.message,
+            errorCode: err.code,
+            hint,
+            recoverable: true
+          },
+          displayText: err.code === "ASSET_NOT_SUPPORTED" ? `Token "${input.from === input.to ? input.from : `${input.from}/${input.to}`}" not in standard registry \u2014 searching for full coin type.` : `No swap route available for ${input.from} \u2192 ${input.to}.`
+        };
+      }
       throw err;
     }
   }
@@ -5721,6 +5753,17 @@ Only offer to execute actions you have tools for. If you retrieved a quote, data
 - "Is protocol X safe?" / "Tell me about NAVI": protocol_deep_dive with the slug.
 - "Full account report" / "account summary" / "give me everything" / "complete overview": triggers the \`account_report\` recipe \u2014 when the recipe block appears, follow EVERY step including all six tool calls. Each step renders a distinct rich card; skipping a step means a missing card.
 
+## Recoverable tool errors (deterministic recovery paths)
+- **\`swap_quote\` or \`swap_execute\` returns \`{ errorCode: 'ASSET_NOT_SUPPORTED', recoverable: true, hint: ... }\`**: the symbol isn't in the standard registry. Call \`navi_navi_search_tokens\` with the symbol \u2192 take the returned full coin type \u2192 retry the swap with that full coin type string (e.g. \`0x83556457...::spring_sui::SPRING_SUI\` instead of \`SSUI\`). Don't apologize, just recover.
+- **\`swap_quote\` returns \`{ errorCode: 'SWAP_FAILED', recoverable: true }\`**: no route or insufficient liquidity. Call \`balance_check\` to confirm the source token is held with the expected amount, then either: try a smaller amount, or ask the user if they want to swap via an intermediate token (e.g. via SUI).
+- **Always check \`recoverable: true\` first** \u2014 if a tool result has that flag, do the suggested next action without asking the user. Recovery is the agent's job.
+
+## Authentication (you CANNOT log users in or out)
+- You have NO tool to log users in, log users out, sign them in, or sign them out. You cannot end their session, switch accounts, or clear cookies.
+- If a user types "logout", "sign out", "log out", "exit", or any variant: tell them "Tap the avatar in the top-right and choose Sign Out" \u2014 do NOT narrate fake success. Saying "you're logged out" when they aren't is the worst possible behavior.
+- If a user types "login", "sign in", "log in": tell them "Tap Sign In with Google in the top-right" \u2014 same rule.
+- If their session has expired (you'll see \`_sessionExpired: true\` on a tool result, or a "Your sign-in session has expired" message): tell them to tap **Sign back in** \u2014 the session-expired card has a button right there. Don't tell them to "logout and log back in" \u2014 there's nothing to log out from.
+
 ## Safety
 - Never encourage risky financial behavior.
 - Warn when health factor < 1.5.
@@ -6595,7 +6638,9 @@ function microcompact(messages, tools) {
   const cacheableByName = /* @__PURE__ */ new Map();
   if (tools) {
     for (const t of tools) {
-      cacheableByName.set(t.name, t.cacheable ?? true);
+      const explicit = t.cacheable;
+      const isMutating = t.flags?.mutating === true;
+      cacheableByName.set(t.name, explicit ?? !isMutating);
     }
   }
   const dedupedToolUseIds = /* @__PURE__ */ new Set();
@@ -7073,6 +7118,8 @@ var EarlyToolDispatcher = class {
       }
       return result;
     });
+    promise.catch(() => {
+    });
     this.entries.push({ call, tool, promise, deduped: false, readAttemptCount });
     return true;
   }