@t2000/engine 0.43.0 → 0.45.0

package/dist/index.js

@@ -181,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
@@ -1013,6 +1012,34 @@ var KNOWN_TARGETS = [
   [/::deepbook/, "swap"],
   [/::transfer::public_transfer/, "send"]
 ];
+var LABEL_PATTERNS = [
+  [/::pay(?:ment_kit|_kit)?::|::create_payment_link|::pay_link/, "payment_link"],
+  [/::create_invoice|::invoice::/, "invoice"],
+  [/::deposit|::supply|::mint_ctokens/, "deposit"],
+  [/::withdraw|::redeem|::redeem_ctokens/, "withdraw"],
+  [/::borrow/, "borrow"],
+  [/::repay/, "repay"],
+  [/::claim_reward|::claim::|::claim_incentive/, "claim"],
+  [/::stake/, "stake"],
+  [/::unstake|::burn::/, "unstake"],
+  [/::liquidate/, "liquidate"]
+];
+function fallbackLabel(targets) {
+  if (!targets.length) return "on-chain";
+  const first = targets[0];
+  const parts = first.split("::");
+  if (parts.length >= 2 && parts[1]) return parts[1].toLowerCase();
+  return "on-chain";
+}
+function classifyLabel(targets, commandTypes) {
+  for (const target of targets) {
+    for (const [pattern, label] of LABEL_PATTERNS) {
+      if (pattern.test(target)) return label;
+    }
+  }
+  if (commandTypes.includes("TransferObjects") && !commandTypes.includes("MoveCall")) return "send";
+  return fallbackLabel(targets);
+}
 function resolveOwner(owner) {
   if (typeof owner === "object" && owner.AddressOwner) return owner.AddressOwner;
   if (typeof owner === "string") return owner;
@@ -1065,9 +1092,23 @@ function parseRpcTx(tx, address) {
     recipient = recipientChange ? resolveOwner(recipientChange.owner) ?? void 0 : void 0;
   }
   const timestampMs = Number(tx.timestampMs ?? 0);
+  const action = classifyAction(moveCallTargets, commandTypes);
+  let label = classifyLabel(moveCallTargets, commandTypes);
+  const labelMatchedSpecific = LABEL_PATTERNS.some(([p]) => moveCallTargets.some((t) => p.test(t)));
+  if (action === "lending" && !labelMatchedSpecific) {
+    const userNonSuiOutflow = changes.find(
+      (c) => resolveOwner(c.owner) === address && c.coinType !== SUI_TYPE && BigInt(c.amount) < 0n
+    );
+    const userNonSuiInflow = changes.find(
+      (c) => resolveOwner(c.owner) === address && c.coinType !== SUI_TYPE && BigInt(c.amount) > 0n
+    );
+    if (userNonSuiOutflow) label = "deposit";
+    else if (userNonSuiInflow) label = "withdraw";
+  }
   return {
     digest: tx.digest,
-    action: classifyAction(moveCallTargets, commandTypes),
+    action,
+    label,
     amount,
     asset,
     recipient,
@@ -1166,6 +1207,42 @@ var transactionHistoryTool = buildTool({
   // `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;