@t2000/engine 1.12.0 → 1.13.0

package/dist/index.d.ts

@@ -934,6 +934,29 @@ interface PendingActionStep {
     description: string;
     /** Optional modifiable fields for THIS step (rare in v1; sourced from `tool-modifiable-fields.ts`). */
     modifiableFields?: PendingActionModifiableField[];
+    /**
+     * [SPEC 13 Phase 1] Index of an earlier step whose output coin handle
+     * is consumed as THIS step's input coin. When set, the host's
+     * `composeTx({ steps })` call must thread `priorOutputs[N]` into this
+     * step's appender as `inputCoin` (chain mode), skipping the wallet
+     * pre-fetch path. The producer at index `N` MUST be a tool that
+     * returns a coin handle (`withdraw`, `borrow`, `swap_execute`,
+     * `volo_stake`, `volo_unstake`); the consumer at this index MUST be
+     * a tool that accepts an input coin (`save_deposit`, `repay_debt`,
+     * `send_transfer`, `swap_execute`, `volo_stake`, `volo_unstake`).
+     *
+     * Populated by `composeBundleFromToolResults` for whitelisted
+     * producer→consumer pairs (see `compose-bundle.ts` `VALID_PAIRS`).
+     * Hosts that don't yet honour this field fall back to wallet-mode
+     * coin fetching at execute time — which is exactly the pre-Phase-1
+     * behaviour and remains correct for the 7 Phase 0 whitelisted pairs
+     * because every producer in those pairs leaves its output in the
+     * user's wallet via a terminal `tx.transferObjects([coin], sender)`.
+     *
+     * Pre-condition (validated by `composeTx` at execute time):
+     *   `inputCoinFromStep < currentStepIndex` (forward-only references).
+     */
+    inputCoinFromStep?: number;
 }
 /**
  * Serializable description of a write tool that needs user approval.

package/dist/index.js

@@ -6746,6 +6746,36 @@ function checkValidPair(producer, consumer) {
   const pair = `${producer}->${consumer}`;
   return VALID_PAIRS.has(pair) ? { ok: true, pair } : { ok: false, pair };
 }
+function inferProducerOutputAsset(toolName, input) {
+  if (typeof input !== "object" || input === null) return null;
+  const i = input;
+  if (toolName === "swap_execute") {
+    return typeof i.to === "string" ? i.to.toLowerCase() : null;
+  }
+  if (toolName === "withdraw" || toolName === "borrow") {
+    return typeof i.asset === "string" ? i.asset.toLowerCase() : "usdc";
+  }
+  return null;
+}
+function inferConsumerInputAsset(toolName, input) {
+  if (typeof input !== "object" || input === null) return null;
+  const i = input;
+  if (toolName === "send_transfer" || toolName === "save_deposit" || toolName === "repay_debt") {
+    return typeof i.asset === "string" ? i.asset.toLowerCase() : "usdc";
+  }
+  if (toolName === "swap_execute") {
+    return typeof i.from === "string" ? i.from.toLowerCase() : null;
+  }
+  return null;
+}
+function shouldChainCoin(producer, consumer) {
+  const pair = `${producer.name}->${consumer.name}`;
+  if (!VALID_PAIRS.has(pair)) return false;
+  const out = inferProducerOutputAsset(producer.name, producer.input);
+  const inA = inferConsumerInputAsset(consumer.name, consumer.input);
+  if (!out || !inA) return false;
+  return out === inA;
+}
 function composeBundleFromToolResults(input) {
   if (input.pendingWrites.length < 2) {
     throw new Error(
@@ -6773,6 +6803,13 @@ function composeBundleFromToolResults(input) {
       ...modifiableFields?.length ? { modifiableFields } : {}
     };
   });
+  for (let i = 1; i < input.pendingWrites.length; i++) {
+    const producer = input.pendingWrites[i - 1];
+    const consumer = input.pendingWrites[i];
+    if (shouldChainCoin(producer, consumer)) {
+      steps[i].inputCoinFromStep = i - 1;
+    }
+  }
   const regenerateToolUseIds = input.readResults.filter((r) => REGENERATABLE_READ_TOOLS.has(r.toolName)).map((r) => r.toolUseId);
   const canRegenerate = regenerateToolUseIds.length > 0;
   let quoteAge;