@t2000/engine 0.42.0 → 0.43.0

package/dist/index.d.ts

@@ -625,6 +625,18 @@ interface Tool<TInput = unknown, TOutput = unknown> {
     maxResultSizeChars?: number;
     /** Custom truncation strategy. Falls back to generic slice + hint when omitted. */
     summarizeOnTruncate?: (result: string, maxChars: number) => string;
+    /**
+     * [v1.5.1] Whether `microcompact` may dedupe this tool's results across
+     * multiple calls with identical input. Default `true` — most tools are
+     * effectively pure within a session (price lookups, protocol info,
+     * yield pools). Set to `false` for tools whose result depends on
+     * mutable on-chain state and therefore changes after writes
+     * (`balance_check`, `savings_info`, `health_check`,
+     * `transaction_history`). Non-cacheable tools are excluded from the
+     * `seen` map entirely, so neither this call nor any later call with
+     * the same input gets replaced with a "[Same result …]" back-reference.
+     */
+    cacheable?: boolean;
 }
 type ThinkingEffort = 'low' | 'medium' | 'high' | 'max';
 type ThinkingConfig = {
@@ -945,6 +957,11 @@ interface BuildToolOptions<TInput, TOutput> {
     preflight?: (input: TInput) => PreflightResult;
     maxResultSizeChars?: number;
     summarizeOnTruncate?: (result: string, maxChars: number) => string;
+    /**
+     * [v1.5.1] See `Tool.cacheable`. Default `true`. Set `false` for
+     * tools whose results depend on mutable on-chain state.
+     */
+    cacheable?: boolean;
 }
 declare function buildTool<TInput, TOutput>(opts: BuildToolOptions<TInput, TOutput>): Tool<TInput, TOutput>;
 declare function toolsToDefinitions(tools: Tool[]): {
@@ -1180,11 +1197,23 @@ interface MicrocompactResult extends Array<Message> {
  * the full prior result with a compact back-reference. Runs before any
  * LLM-based compaction and costs nothing.
  *
+ * [v1.5.1] Tools may opt out of dedupe by setting `cacheable: false` on
+ * their `Tool` definition. Non-cacheable tools (e.g. `balance_check`,
+ * `savings_info`, `health_check`, `transaction_history`) are excluded
+ * from the `seen` map entirely, so neither the current call nor any
+ * later call with identical inputs gets replaced — necessary because
+ * their results depend on mutable on-chain state that writes invalidate.
+ *
  * 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.
+ *
+ * @param messages — conversation ledger to compact.
+ * @param tools    — optional tool registry consulted to resolve the
+ *                   per-tool `cacheable` flag. Omit to dedupe every
+ *                   tool (legacy behavior — back-compat).
  */
-declare function microcompact(messages: readonly Message[]): MicrocompactResult;
+declare function microcompact(messages: readonly Message[], tools?: readonly Tool[]): MicrocompactResult;
 
 /**
  * EarlyToolDispatcher — dispatches read-only tools mid-stream.

package/dist/index.js

@@ -23,7 +23,8 @@ function buildTool(opts) {
     flags: opts.flags ?? {},
     preflight: opts.preflight,
     maxResultSizeChars: opts.maxResultSizeChars,
-    summarizeOnTruncate: opts.summarizeOnTruncate
+    summarizeOnTruncate: opts.summarizeOnTruncate,
+    cacheable: opts.cacheable
   };
 }
 function toolsToDefinitions(tools) {
@@ -557,6 +558,10 @@ var balanceCheckTool = buildTool({
   inputSchema: z.object({}),
   jsonSchema: { type: "object", properties: {}, required: [] },
   isReadOnly: true,
+  // [v1.5.1] Wallet contents change after every send/swap/save/etc.
+  // Microcompact must NEVER dedupe these calls — each one reflects a
+  // different on-chain state.
+  cacheable: false,
   async call(_input, context) {
     if (hasNaviMcp(context)) {
       const address = getWalletAddress(context);
@@ -850,6 +855,9 @@ var savingsInfoTool = buildTool({
   inputSchema: z.object({}),
   jsonSchema: { type: "object", properties: {}, required: [] },
   isReadOnly: true,
+  // [v1.5.1] NAVI deposits change on save_deposit / withdraw / claim.
+  // Each call reflects a fresh on-chain snapshot — never dedupe.
+  cacheable: false,
   async call(_input, context) {
     if (context.positionFetcher && context.walletAddress) {
       const sp = await context.positionFetcher(context.walletAddress);
@@ -910,6 +918,9 @@ var healthCheckTool = buildTool({
   inputSchema: z.object({}),
   jsonSchema: { type: "object", properties: {}, required: [] },
   isReadOnly: true,
+  // [v1.5.1] Health factor changes on every borrow / repay / collateral
+  // movement and even passively as oracle prices update. Never dedupe.
+  cacheable: false,
   async call(_input, context) {
     if (context.positionFetcher && context.walletAddress) {
       const sp = await context.positionFetcher(context.walletAddress);
@@ -1151,6 +1162,10 @@ var transactionHistoryTool = buildTool({
   },
   isReadOnly: true,
   maxResultSizeChars: 8e3,
+  // [v1.5.1] New transactions land continuously. Even with an explicit
+  // `date` filter the dedupe is wrong post-write because the just-
+  // executed write may now be in history. Never dedupe.
+  cacheable: false,
   async call(input, context) {
     const limit = input.limit ?? 10;
     const action = input.action;
@@ -3724,15 +3739,23 @@ function extractConversationText(messages) {
 }
 
 // src/compact/microcompact.ts
-function microcompact(messages) {
+function microcompact(messages, tools) {
   const seen = /* @__PURE__ */ new Map();
   let toolUseIndex = 0;
   const toolUseInputs = /* @__PURE__ */ new Map();
+  const cacheableByName = /* @__PURE__ */ new Map();
+  if (tools) {
+    for (const t of tools) {
+      cacheableByName.set(t.name, t.cacheable ?? true);
+    }
+  }
   const dedupedToolUseIds = /* @__PURE__ */ new Set();
+  const toolNameById = /* @__PURE__ */ new Map();
   for (const msg of messages) {
     for (const block of msg.content) {
       if (block.type === "tool_use") {
         toolUseInputs.set(block.id, `${block.name}:${stableStringify(block.input)}`);
+        toolNameById.set(block.id, block.name);
       }
     }
   }
@@ -3744,6 +3767,11 @@ function microcompact(messages) {
       if (block.type !== "tool_result") return block;
       const key = toolUseInputs.get(block.toolUseId);
       if (!key) return block;
+      const toolName = toolNameById.get(block.toolUseId);
+      if (toolName && cacheableByName.get(toolName) === false) {
+        toolUseIndex++;
+        return block;
+      }
       toolUseIndex++;
       const prior = seen.get(key);
       if (prior && !block.isError) {
@@ -4442,7 +4470,7 @@ var QueryEngine = class {
       };
       const dispatcher = new EarlyToolDispatcher(this.tools, context);
       try {
-        const microcompacted = microcompact(this.messages);
+        const microcompacted = microcompact(this.messages, this.tools);
         this.messages = microcompacted;
         for (const dedupedId of microcompacted.dedupedToolUseIds) {
           yield {