@thirdfy/agent-cli 0.2.35 → 0.2.36

package/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to `@thirdfy/agent-cli` are documented here. The format is b
 
 ## [Unreleased]
 
+## [0.2.36] - 2026-07-25
+
+### Fixed
+
+- `--run-mode agent_wallet` market-data reads use `/api/v1/agent/execute` again and keep the provider payload on the CLI envelope (`raw` plus coerced `data.result`). Version 0.2.34 routed every managed read through `/execute-intent` to avoid an execution-shaped reply, but solo Hermes `agent_wallet` intents come back as an empty queued envelope with no Hyperliquid universe. Live `/execute` still returns the meta payload (often as a JSON string under `data.result`); the CLI now parses that string so EarnClaw pack parsers can find `universe`. Execute-intent remains the fallback only when the execute rail rejects the action (`does not support execute rail`).
+- **MCP parity:** the same rail fix belongs in `thirdfy-mcp` (`walletExecute`) as **0.0.79**. See workspace rule `cli-mcp-parity` and API docs-dev `cli-mcp-parity.md`.
+
+### Changed
+
+- Reads still skip execution-wallet funding checks. Routing and identity preflight still fail closed.
+
 ## [0.2.35] - 2026-07-25
 
 ### Fixed

package/README.md

@@ -40,11 +40,11 @@ Run without global install:
 npx @thirdfy/agent-cli --help
 ```
 
-## What's new in v0.2.35
+## What's new in v0.2.36
 
-- Read-only actions return the provider payload directly in every run mode. Market data reads such as `get_hyperliquid_perps_meta` no longer come back wrapped as an execution intent, and `--run-mode self` no longer refuses them.
-- Read detection now matches the Thirdfy action catalog, so `fetch_*`, `show_*`, `dogeos_get_*`, and `*_info` actions are recognized as reads.
-- Reads are not gated on execution-wallet funding. The execution address is still reported, but an unfunded wallet does not block a read. Routing and identity checks still apply.
+- `--run-mode agent_wallet` market-data reads (`get_hyperliquid_perps_meta` and siblings) keep the live provider payload from `/api/v1/agent/execute`, including stringified `data.result` coercion, so pack callers can parse the Hyperliquid universe again.
+- Execute-intent is only used for managed reads when the execute rail rejects the action. Solo agent_wallet intents no longer replace a successful market-data reply with an empty queue.
+- Reads still skip funding checks; routing and identity preflight still fail closed.
 
 Older versions: see [CHANGELOG.md](./CHANGELOG.md) and [GitHub Releases](https://github.com/thirdfy/agent-cli/releases).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thirdfy/agent-cli",
-  "version": "0.2.35",
+  "version": "0.2.36",
   "description": "Thirdfy Agent CLI for onboarding, governance preflight, execute-intent, and status polling.",
   "type": "module",
   "bin": {

package/src/runtime/execution/runners.mjs

@@ -84,21 +84,68 @@ function isReadOnlyAction(resolved) {
   return isReadOnlyResolvedAction(resolved);
 }
 
-// Reads carry no transaction, so wallet balance never blocks them. Every other preflight failure
-// (identity, routing, wallet mismatch) still fails closed, same as a write.
-const FUNDING_ONLY_PREFLIGHT_BLOCKS = new Set(['INSUFFICIENT_FUNDS', 'INVALID_FUNDING_BALANCE']);
-
-function isFundingOnlyPreflightBlock(preflight) {
-  const reason = String(preflight?.blockedReason || '').trim().toUpperCase();
-  return FUNDING_ONLY_PREFLIGHT_BLOCKS.has(reason);
-}
-
 function shouldFallbackAgentWalletToExecuteIntent(resolved, response) {
   if (!isReadOnlyAction(resolved)) return false;
   const err = String(response?.error || response?.message || '').toLowerCase();
   return err.includes('does not support execute rail');
 }
 
+// Managed /execute often returns provider payloads as JSON strings under data.result. Pack parsers
+// (and find_value_by_key) need a real object tree, so coerce strings that look like JSON.
+function coerceJsonTreeValue(value) {
+  if (typeof value !== 'string') return value;
+  const trimmed = value.trim();
+  if (!trimmed || (trimmed[0] !== '{' && trimmed[0] !== '[')) return value;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return value;
+  }
+}
+
+function shapeManagedExecuteReadResponse(response) {
+  if (!response || typeof response !== 'object') return response;
+  const data =
+    response.data && typeof response.data === 'object' ? { ...response.data } : response.data;
+  if (data && typeof data === 'object' && Object.prototype.hasOwnProperty.call(data, 'result')) {
+    data.result = coerceJsonTreeValue(data.result);
+  }
+  return { ...response, data };
+}
+
+function normalizeManagedExecuteResponse(response, { preflight, payload, isRead }) {
+  const shaped = isRead ? shapeManagedExecuteReadResponse(response) : response;
+  const normalized = normalizeIntentResponse({
+    success: Boolean(shaped?.success),
+    status: shaped?.success ? 'completed' : 'failed',
+    mode: 'agent_wallet',
+    txHash: shaped?.txHash || null,
+    blockedReason: shaped?.blockedReason || shaped?.data?.blockedReason || null,
+    blockedStage: shaped?.blockedStage || shaped?.data?.blockedStage || null,
+    error: shaped?.error || null,
+    executionWalletAddress:
+      shaped?.executionWalletAddress || shaped?.data?.executionWalletAddress || null,
+    signerMethod: 'managed_wallet_server',
+    idempotencyKey: payload.executionIdempotencyKey || null,
+    executionWalletPreflight: preflight,
+    amountNormalization:
+      shaped?.amountNormalization || shaped?.data?.amountNormalization || null,
+    // Reads must keep provider payload on the envelope. EarnClaw packs parse
+    // data.raw.data.result (see parse_thirdfy_action_result).
+    ...(isRead && shaped?.data !== undefined ? { data: shaped.data } : {}),
+    raw: shaped,
+  });
+  normalized.executionWalletAddress =
+    shaped?.executionWalletAddress || shaped?.data?.executionWalletAddress || null;
+  normalized.signerMethod = 'managed_wallet_server';
+  normalized.executionWalletPreflight = preflight;
+  normalized.amountNormalization =
+    shaped?.amountNormalization || shaped?.data?.amountNormalization || null;
+  normalized.raw = shaped;
+  normalized.idempotencyKey = payload.executionIdempotencyKey || null;
+  return normalized;
+}
+
 async function runPreflightByMode(runMode, ctx, flags, resolved, options = {}) {
   const resolvedAction = resolved.resolvedAction;
   if (runMode === 'agent_wallet') {
@@ -417,44 +464,18 @@ async function runReadOnlyActionViaIntentRail(ctx, flags, resolved, options, pre
 }
 
 async function executeManagedWalletRun(ctx, flags, resolved, options) {
-  // Read-only actions carry no transaction. Routing them through the managed-wallet execute rail
-  // returns an execution envelope instead of the queried data, which silently starves callers that
-  // asked for market state (see earnclaw-api HL universe probe regression, 2026-07-25).
-  // The wallet address is still resolved for response parity, but a read is never gated on funding.
-  if (isReadOnlyAction(resolved)) {
-    // Do not swallow lookup/routing errors: writes let them propagate, and reads must fail closed
-    // the same way (wallet mismatch, missing identity, failed /execution-wallet).
-    const readPreflight = await resolveManagedExecutionPreflight(ctx, flags, resolved, {
-      runMode: 'agent_wallet',
-      requireFundingCheck: false,
-      preflightSeed: options?.managedPreflight,
-    });
-    // Funding is intentionally skipped for reads (`requireFundingCheck: false`), but routing
-    // failures (wallet mismatch, missing identity, failed address seed) must still fail closed.
-    if (readPreflight && readPreflight.success === false && !isFundingOnlyPreflightBlock(readPreflight)) {
-      const normalized = normalizeIntentResponse({
-        success: false,
-        status: 'failed',
-        mode: 'agent_wallet',
-        blockedReason: readPreflight.blockedReason || 'PRECHECK_FAILED',
-        blockedStage: readPreflight.blockedStage || 'routing',
-        error: readPreflight.error || 'Managed wallet preflight failed',
-        preflightBlocked: true,
-        executionWalletAddress: readPreflight.executionWalletAddress || null,
-        executionWalletPreflight: readPreflight,
-      });
-      normalized.executionWalletAddress = readPreflight.executionWalletAddress || null;
-      normalized.executionWalletPreflight = readPreflight;
-      return normalized;
-    }
-    return runReadOnlyActionViaIntentRail(ctx, flags, resolved, options, readPreflight);
-  }
+  // Market-data reads under agent_wallet must use /execute and keep the provider payload on the
+  // envelope (raw + parsed data.result). Routing them only through /execute-intent was the 0.2.34
+  // attempt to avoid a burial bug, but solo Hermes agent_wallet intents come back as an empty
+  // queued envelope with no universe. Live /execute still returns the Hyperliquid meta payload
+  // (often as a JSON string under data.result). Reads skip funding gates; routing still fails closed.
+  const isRead = isReadOnlyAction(resolved);
   const skipPreflight = Boolean(options?.skipPreflight);
   let preflight = null;
   if (!skipPreflight) {
     preflight = await resolveManagedExecutionPreflight(ctx, flags, resolved, {
       runMode: 'agent_wallet',
-      requireFundingCheck: true,
+      requireFundingCheck: !isRead,
       preflightSeed: options?.managedPreflight,
     });
     if (!preflight.success) {
@@ -490,28 +511,7 @@ async function executeManagedWalletRun(ctx, flags, resolved, options) {
       null;
     return intentResult;
   }
-  const normalized = normalizeIntentResponse({
-    success: Boolean(response?.success),
-    status: response?.success ? 'completed' : 'failed',
-    mode: 'agent_wallet',
-    txHash: response?.txHash || null,
-    blockedReason: response?.blockedReason || response?.data?.blockedReason || null,
-    blockedStage: response?.blockedStage || response?.data?.blockedStage || null,
-    error: response?.error || null,
-    executionWalletAddress: response?.executionWalletAddress || response?.data?.executionWalletAddress || null,
-    signerMethod: 'managed_wallet_server',
-    idempotencyKey: payload.executionIdempotencyKey || null,
-    executionWalletPreflight: preflight,
-    amountNormalization: response?.amountNormalization || response?.data?.amountNormalization || null,
-    raw: response,
-  });
-  normalized.executionWalletAddress = response?.executionWalletAddress || response?.data?.executionWalletAddress || null;
-  normalized.signerMethod = 'managed_wallet_server';
-  normalized.executionWalletPreflight = preflight;
-  normalized.amountNormalization = response?.amountNormalization || response?.data?.amountNormalization || null;
-  normalized.raw = response;
-  normalized.idempotencyKey = payload.executionIdempotencyKey || null;
-  return normalized;
+  return normalizeManagedExecuteResponse(response, { preflight, payload, isRead });
 }
 
 async function executeSelfRun(ctx, flags, resolved, options) {
@@ -680,15 +680,19 @@ async function resolveManagedExecutionPreflight(ctx, flags, resolved, options =
     try {
       parsedRawBalance = BigInt(rawBalance);
     } catch {
-      return {
-        success: false,
-        blockedReason: 'INVALID_FUNDING_BALANCE',
-        blockedStage: 'sizing',
-        error: `Execution wallet ${executionWalletAddress || 'unknown'} returned invalid funding token balance.`,
-        executionWalletAddress,
-        signerMethod,
-        fundingTokenBalance: response?.fundingTokenBalance || null,
-      };
+      // Reads pass requireFundingCheck: false; a malformed balance must not block them.
+      // Writes still fail closed on unparseable fundingTokenBalance.raw.
+      if (options.requireFundingCheck) {
+        return {
+          success: false,
+          blockedReason: 'INVALID_FUNDING_BALANCE',
+          blockedStage: 'sizing',
+          error: `Execution wallet ${executionWalletAddress || 'unknown'} returned invalid funding token balance.`,
+          executionWalletAddress,
+          signerMethod,
+          fundingTokenBalance: response?.fundingTokenBalance || null,
+        };
+      }
     }
   }
   const expectedWallet = String(flags.walletAddress || flags.executionWalletAddress || '').trim().toLowerCase();