@t2000/engine 0.42.0 → 0.44.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) {
@@ -180,14 +181,13 @@ function budgetToolResult(data, tool) {
   }
   const preview = serialized.slice(0, tool.maxResultSizeChars);
   const linesOmitted = serialized.split("\n").length - preview.split("\n").length;
-  const truncated = `${preview}
-
-[Truncated \u2014 ${linesOmitted} lines omitted. Call ${tool.name} with narrower parameters (e.g. smaller date range or limit) to see more.]`;
-  try {
-    return JSON.parse(truncated);
-  } catch {
-    return truncated;
+  const note = `[Truncated \u2014 ${linesOmitted} lines omitted. Call ${tool.name} with narrower parameters (e.g. smaller date range or limit) to see more.]`;
+  if (typeof data === "object" && data !== null) {
+    return { _truncated: true, _preview: preview, _note: note };
   }
+  return `${preview}
+
+${note}`;
 }
 
 // src/tool-flags.ts
@@ -557,6 +557,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 +854,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 +917,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 +1161,46 @@ 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,
+  /**
+   * [v1.5.2] Custom truncation that preserves the structured shape.
+   *
+   * The default `budgetToolResult` slices the JSON string at the byte
+   * limit, appends a "[Truncated…]" note, and tries `JSON.parse` — which
+   * always fails for sliced JSON, so the engine falls back to returning
+   * the raw string. The frontend's `transaction_history` card renderer
+   * then sees `typeof data !== 'object'` and bails, so the rich card
+   * never renders even though the LLM has the full text.
+   *
+   * Strategy: progressively halve the `transactions` array until the
+   * serialized payload fits, then stamp `_truncated: true` and the
+   * original length so the LLM knows to recall with `limit` if it needs
+   * older entries. Result is always valid JSON, always object-shaped.
+   */
+  summarizeOnTruncate(serialized, maxChars) {
+    let parsed;
+    try {
+      parsed = JSON.parse(serialized);
+    } catch {
+      return JSON.stringify({
+        transactions: [],
+        count: 0,
+        _truncated: true,
+        _note: "Result exceeded size budget and could not be summarized."
+      });
+    }
+    const original = Array.isArray(parsed.transactions) ? parsed.transactions : [];
+    let trimmed = original.slice();
+    let payload = JSON.stringify({ ...parsed, transactions: trimmed, _truncated: true, _originalCount: original.length });
+    while (payload.length > maxChars && trimmed.length > 1) {
+      trimmed = trimmed.slice(0, Math.max(1, Math.floor(trimmed.length / 2)));
+      payload = JSON.stringify({ ...parsed, transactions: trimmed, _truncated: true, _originalCount: original.length });
+    }
+    return payload;
+  },
   async call(input, context) {
     const limit = input.limit ?? 10;
     const action = input.action;
@@ -3724,15 +3774,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 +3802,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 +4505,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 {