@thirdfy/agent-cli 0.2.76 → 0.2.78

package/src/runtime/certification/executionCertify.mjs

@@ -3,6 +3,7 @@ import { createHash } from 'node:crypto';
 import { CLI_MANIFEST } from '../../cli/manifest.mjs';
 import { validateParamsSchema, sanitizeParamsForSchemaValidation } from '../validation/paramsSchema.mjs';
 import { VENUE_WRITE_ACTION_FIXTURES } from './venueActionSchemas.mjs';
+import { toLegacyVenueActionKey } from '../../core/venueBrand.mjs';
 
 const require = createRequire(import.meta.url);
 
@@ -23,7 +24,8 @@ const AUTHORITY_INPUT_CHECKS = [
 ];
 
 function normalizeActionKey(action) {
-  return String(action || '').trim().replace(/_/g, '-').toLowerCase();
+  // Brand-insensitive: a live `place_veranta_perps_order` row replaces the `place_avantis_perps_order` fixture.
+  return toLegacyVenueActionKey(action).replace(/_/g, '-');
 }
 
 function isWriteAction(action) {

package/src/runtime/certification/venueActionSchemas.mjs

@@ -218,8 +218,10 @@ export const VENUE_WRITE_ACTION_FIXTURES = [
     validSample: { orderId: '0xabc' },
   },
   {
+    // Veranta (formerly Avantis). Fixture ids keep the Avantis spelling so the default schema digest
+    // is unchanged; the Veranta names are aliases.
     action: 'place_avantis_perps_order',
-    aliases: ['place-avantis-perps-order'],
+    aliases: ['place-avantis-perps-order', 'place_veranta_perps_order', 'place-veranta-perps-order'],
     provider: 'avantis',
     authorityInputs: ['agentApiKey', 'estimatedAmountUsd'],
     paramsSchema: {
@@ -249,7 +251,7 @@ export const VENUE_WRITE_ACTION_FIXTURES = [
   },
   {
     action: 'cancel_avantis_perps_order',
-    aliases: ['cancel-avantis-perps-order'],
+    aliases: ['cancel-avantis-perps-order', 'cancel_veranta_perps_order', 'cancel-veranta-perps-order'],
     provider: 'avantis',
     authorityInputs: ['agentApiKey'],
     paramsSchema: {
@@ -267,7 +269,7 @@ export const VENUE_WRITE_ACTION_FIXTURES = [
   },
   {
     action: 'close_avantis_position',
-    aliases: ['close-avantis-position'],
+    aliases: ['close-avantis-position', 'close_veranta_position', 'close-veranta-position'],
     provider: 'avantis',
     authorityInputs: ['agentApiKey', 'estimatedAmountUsd'],
     paramsSchema: {

package/src/runtime/execution/amounts.mjs

@@ -3,7 +3,62 @@ import { createCliError } from '../../core/envelope.mjs';
 export function createExecutionAmounts() {
 function shouldApplySwapAmountContract(actionName) {
   const action = String(actionName || '').trim().toLowerCase();
-  return action === 'swap' || /(^|:|-)swap$/.test(action);
+  return action === 'swap' || action === 'execute_optimal_swap' || /(^|:|-)swap$/.test(action);
+}
+
+function normalizeContractActionKey(actionName) {
+  return String(actionName || '').trim().toLowerCase().replace(/_/g, '-');
+}
+
+/** `deposit_earn_position` takes `amount` as a decimal token-unit string (contract `earn_deposit_decimal_amount`). */
+function shouldApplyEarnDepositAmountContract(actionName) {
+  return /(^|:)deposit-earn-position$/.test(normalizeContractActionKey(actionName));
+}
+
+function hasParamValue(value) {
+  return value !== undefined && value !== null && String(value).trim() !== '';
+}
+
+/**
+ * Accepts `amountHuman` or `amountInHuman` in place of `amount`, as thirdfy-mcp's params gate does
+ * (`earn_deposit_decimal_amount`). Exactly one decimal amount; raw base units are refused, because
+ * the API reads `amount` as token units.
+ */
+function normalizeEarnDepositAmountContract(params) {
+  const hasAmount = hasParamValue(params.amount);
+  const hasAmountHuman = hasParamValue(params.amountHuman);
+  const hasAmountInHuman = hasParamValue(params.amountInHuman);
+  const humanInputs = [hasAmount, hasAmountHuman, hasAmountInHuman].filter(Boolean).length;
+  if (humanInputs > 1) {
+    throw createCliError(
+      'EARN_AMOUNT_AMBIGUOUS',
+      'Provide exactly one earn deposit amount: amount, amountHuman, or amountInHuman.'
+    );
+  }
+  if (humanInputs === 1) {
+    if (hasParamValue(params.amountInRaw) || hasParamValue(params.amountIn)) {
+      throw createCliError(
+        'EARN_AMOUNT_UNIT_AMBIGUOUS',
+        'Provide exactly one earn deposit amount; do not combine amount/amountHuman/amountInHuman with amountInRaw or amountIn.'
+      );
+    }
+    const amount = String(hasAmount ? params.amount : hasAmountHuman ? params.amountHuman : params.amountInHuman).trim();
+    if (!/^\d+(\.\d+)?$/.test(amount)) {
+      throw createCliError(
+        'EARN_AMOUNT_INVALID',
+        'Earn deposits require amount as a decimal token-unit string (example: "100.5").'
+      );
+    }
+    const { amountHuman: _amountHuman, amountInHuman: _amountInHuman, ...rest } = params;
+    return { ...rest, amount };
+  }
+  if (hasParamValue(params.amountInRaw) || hasParamValue(params.amountIn)) {
+    throw createCliError(
+      'EARN_AMOUNT_UNIT_INVALID',
+      'deposit_earn_position expects amount as a decimal token-unit string. Do not pass raw base-unit amountInRaw/amountIn for earn deposits.'
+    );
+  }
+  return params;
 }
 
 function normalizeIntegerRawAmount(input, code = 'AMOUNT_UNIT_INVALID') {
@@ -164,6 +219,11 @@ function normalizeSwapAmountContract(params) {
 
 function prepareActionParamsForFlags(flags, resolvedAction) {
   const parsedParams = parseJsonFlag(flags, 'params');
+  if (shouldApplyEarnDepositAmountContract(resolvedAction)) {
+    flags.__preparedParams = normalizeEarnDepositAmountContract(parsedParams || {});
+    flags.__swapInput = null;
+    return;
+  }
   if (!shouldApplySwapAmountContract(resolvedAction)) {
     flags.__preparedParams = parsedParams;
     flags.__swapInput = null;
@@ -187,6 +247,8 @@ function getPreparedParams(flags) {
     decimalToRawUnits,
     rawUnitsToDecimalString,
     normalizeSwapAmountContract,
+    shouldApplyEarnDepositAmountContract,
+    normalizeEarnDepositAmountContract,
     prepareActionParamsForFlags,
     getPreparedParams,
   };

package/src/runtime/execution/lanes.mjs

@@ -1,4 +1,5 @@
 import { createCliError } from '../../core/envelope.mjs';
+import { toLegacyVenueActionKey } from '../../core/venueBrand.mjs';
 export function createExecutionLanes() {
 const OFFCHAIN_VENUE_ORDER_ACTIONS = new Set([
   'place_hyperliquid_perps_order',
@@ -29,6 +30,7 @@ const OFFCHAIN_VENUE_ORDER_ACTIONS = new Set([
   'condor-executor-create',
   'condor_executor_stop',
   'condor-executor-stop',
+  // Veranta (formerly Avantis): keyed by the Avantis spelling; Veranta names map onto it below.
   'place_avantis_perps_order',
   'place-avantis-perps-order',
   'cancel_avantis_perps_order',
@@ -57,11 +59,11 @@ const OFFCHAIN_VENUE_ORDER_ACTIONS = new Set([
   'cancel-avantis-mm-order',
 ]);
 function enforceOffchainVenueLaneCompatibility(action, runMode) {
-  const normalizedAction = String(action || '').trim().toLowerCase();
+  const normalizedAction = toLegacyVenueActionKey(action);
   if (runMode !== 'self' || !OFFCHAIN_VENUE_ORDER_ACTIONS.has(normalizedAction)) return;
   throw createCliError(
     'OFFCHAIN_VENUE_ORDER_SELF_UNSUPPORTED',
-    'Polymarket CLOB, Hyperliquid perps, Lighter perps, Avantis perps, Hummingbot executor, and Condor executor actions are offchain signed API actions, not EVM build-tx actions. Use self for setup/funding signatures, then run venue orders with --run-mode thirdfy, --run-mode hybrid, or --run-mode agent_wallet.',
+    'Polymarket CLOB, Hyperliquid perps, Lighter perps, Veranta perps, Hummingbot executor, and Condor executor actions are offchain signed API actions, not EVM build-tx actions. Use self for setup/funding signatures, then run venue orders with --run-mode thirdfy, --run-mode hybrid, or --run-mode agent_wallet.',
     {
       recommendedRunModes: ['thirdfy', 'hybrid', 'agent_wallet'],
       setupOnlyRunMode: 'self',

package/src/runtime/execution/payloads.mjs

@@ -4,6 +4,7 @@ import { resolveExecutionContextFromEnv } from '../../core/executionContext.mjs'
 import { requireFlag, parseJsonFlag } from '../../core/args.mjs';
 import { loadProfileConfig } from '../../core/context.mjs';
 import { createCliError } from '../../core/envelope.mjs';
+import { toLegacyVenueActionKey } from '../../core/venueBrand.mjs';
 import { normalizeRunMode, normalizeManagedRunMode, normalizeHybridWalletMode } from '../../core/runMode.mjs';
 import { assertHostedRuntimePolymarketWriteIdempotency } from './hostedRuntimeWriteGate.mjs';
 import { resolveTokenInForFunding } from '../../core/fundingTokenIn.mjs';
@@ -29,10 +30,8 @@ export function mergeConfirmWritesIntoParams(params, flags) {
 export function resolveExecuteEstimatedAmountUsd(action, flags) {
   const fromFlags = Number(flags?.estimatedAmountUsd);
   if (Number.isFinite(fromFlags) && fromFlags > 0) return fromFlags;
-  const key = String(action || '')
-    .trim()
-    .toLowerCase()
-    .replace(/-/g, '_');
+  const key = toLegacyVenueActionKey(action).replace(/-/g, '_');
+  // Veranta onboarding (either spelling).
   if (key === 'complete_avantis_onboarding') return 1;
   return undefined;
 }

package/src/runtime/execution/runners.mjs

@@ -9,7 +9,8 @@ import {
   getEffectiveRunMode,
   parseBooleanFlag,
 } from '../../core/runMode.mjs';
-import { apiGet, apiPost } from '../../core/http.mjs';
+import { apiGet, apiPost, responseHeadersFor } from '../../core/http.mjs';
+import { idempotentReplayFields } from '../../core/hostedRuntimeIdempotency.mjs';
 import { withActionTimeout } from '../../core/actionTimeouts.mjs';
 import { isReadOnlyResolvedAction } from '../../core/readOnlyActions.mjs';
 import { resolveWalletExecuteChainId } from '../../core/walletExecuteChainId.mjs';
@@ -32,6 +33,7 @@ export function createExecutionRunners(deps) {
     buildBitfinexOnboardingCommand,
     inferBitfinexPermissionProfileFromAction,
     resolveAgentApiKey,
+    resolveAgentKey,
     loadEthers,
     signAndBroadcastWithOws,
     readEffectBalances,
@@ -146,9 +148,52 @@ function normalizeManagedExecuteResponse(response, { preflight, payload, isRead
     shaped?.amountNormalization || shaped?.data?.amountNormalization || null;
   normalized.raw = shaped;
   normalized.idempotencyKey = payload.executionIdempotencyKey || null;
+  // A replay means nothing new ran; say so, or the caller reads it as a fresh fill.
+  if (!isRead) {
+    Object.assign(
+      normalized,
+      idempotentReplayFields(response, responseHeadersFor(response), 'executionIdempotencyKey'),
+    );
+  }
   return normalized;
 }
 
+const ROBINHOOD_MAINNET_CHAIN_ID = 4663;
+
+/** Marker a read on the fast path carries instead of an execution-wallet preflight. */
+const READ_FAST_PATH_PREFLIGHT = Object.freeze({ success: true, skipped: 'read_fast_path' });
+
+/**
+ * agent_wallet reads skip the /execution-wallet preflight: the API resolves the agent's execution
+ * wallet itself, so the extra round trip only matters when a read uses its answer: a strict wallet
+ * match, a funding check, or the Robinhood delegated lane. An expected wallet equal to the agent key
+ * is not a separate wallet to match first; the wallet the API reports is checked after the read.
+ * Mirrors thirdfy-mcp `walletExecute` readFastPath.
+ */
+function shouldUseManagedReadFastPath(flags, resolved, options = {}) {
+  if (!isReadOnlyAction(resolved)) return false;
+  if (options.requireFundingCheck === true) return false;
+  const runMode = String(flags.runMode || 'agent_wallet').trim().toLowerCase();
+  if (runMode !== 'agent_wallet') return false;
+  const expectedWallet = String(flags.walletAddress || flags.executionWalletAddress || '').trim().toLowerCase();
+  const agentKey = String(typeof resolveAgentKey === 'function' ? resolveAgentKey(flags) : flags.agentKey || '')
+    .trim()
+    .toLowerCase();
+  if (expectedWallet && expectedWallet !== agentKey) return false;
+  let chainId;
+  try {
+    chainId = resolveWalletExecuteChainId({
+      action: String(resolved?.resolvedAction || flags.action || '').trim(),
+      chainId: flags.chainId,
+      params: getPreparedParams(flags),
+    });
+  } catch {
+    // Unresolvable chain (e.g. a CCTP quote without sourceChainId): the preflight path reports it.
+    return false;
+  }
+  return Number(chainId) !== ROBINHOOD_MAINNET_CHAIN_ID;
+}
+
 async function runPreflightByMode(runMode, ctx, flags, resolved, options = {}) {
   const resolvedAction = resolved.resolvedAction;
   if (runMode === 'agent_wallet') {
@@ -439,6 +484,9 @@ async function executeThirdfyRun(ctx, flags, resolved, options, runMode = 'third
   const response = await apiPost(actionCtx, '/api/v1/agent/execute-intent', payload);
   const normalized = normalizeIntentResponse(response);
   normalized.idempotencyKey = payload.idempotencyKey;
+  if (!isReadOnlyAction(resolved)) {
+    Object.assign(normalized, idempotentReplayFields(response, responseHeadersFor(response), 'idempotencyKey'));
+  }
   return normalized;
 }
 
@@ -465,7 +513,7 @@ async function runReadOnlyActionViaIntentRail(ctx, flags, resolved, options, pre
   intentResult.routeFallback = 'execute_intent_read_only';
   if (preflight) {
     intentResult.executionWalletPreflight = preflight;
-    intentResult.executionWalletAddress = preflight.executionWalletAddress || null;
+    intentResult.executionWalletAddress = preflight.executionWalletAddress || intentResult.executionWalletAddress || null;
   }
   intentResult.signerMethod = 'managed_wallet_server';
   return intentResult;
@@ -479,8 +527,11 @@ async function executeManagedWalletRun(ctx, flags, resolved, options) {
   // (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) {
+  // A seeded preflight (Hyperliquid/Lighter/Veranta address defaults) already ran; reuse it.
+  const readFastPath =
+    !skipPreflight && !options?.managedPreflight && shouldUseManagedReadFastPath(flags, resolved, options);
+  let preflight = readFastPath ? READ_FAST_PATH_PREFLIGHT : null;
+  if (!skipPreflight && !readFastPath) {
     preflight = await resolveManagedExecutionPreflight(ctx, flags, resolved, {
       runMode: 'agent_wallet',
       requireFundingCheck: !isRead,
@@ -510,8 +561,19 @@ async function executeManagedWalletRun(ctx, flags, resolved, options) {
   });
   const actionCtx = withActionTimeout(ctx, resolved);
   const response = await apiPost(actionCtx, '/api/v1/agent/execute', payload);
+  if (readFastPath) {
+    const mismatch = fastPathWalletMismatch(flags, response);
+    if (mismatch) return mismatch;
+  }
   if (shouldFallbackAgentWalletToExecuteIntent(resolved, response)) {
-    const intentResult = await runReadOnlyActionViaIntentRail(ctx, flags, resolved, options, preflight);
+    // On the fast path the wallet comes from the /execute answer, not a preflight.
+    const fallbackPreflight = readFastPath
+      ? {
+          ...READ_FAST_PATH_PREFLIGHT,
+          executionWalletAddress: response?.executionWalletAddress || response?.data?.executionWalletAddress || null,
+        }
+      : preflight;
+    const intentResult = await runReadOnlyActionViaIntentRail(ctx, flags, resolved, options, fallbackPreflight);
     if (isEmptyQueuedExecuteIntent(intentResult.raw || intentResult)) {
       intentResult.success = false;
       intentResult.status = 'failed';
@@ -527,6 +589,33 @@ async function executeManagedWalletRun(ctx, flags, resolved, options) {
   return normalizeManagedExecuteResponse(response, { preflight, payload, isRead });
 }
 
+/**
+ * The fast path only runs when the expected wallet is empty or equals the agent key. The preflight
+ * path refuses a wallet that differs from the execution wallet, so apply the same rule to the wallet
+ * the API reports for the read.
+ */
+function fastPathWalletMismatch(flags, response) {
+  const expectedWallet = String(flags.walletAddress || flags.executionWalletAddress || '').trim().toLowerCase();
+  if (!expectedWallet || parseBooleanFlag(flags.allowWalletMismatch, false)) return null;
+  const apiWallet = String(response?.executionWalletAddress || response?.data?.executionWalletAddress || '')
+    .trim()
+    .toLowerCase();
+  if (!apiWallet || apiWallet === expectedWallet) return null;
+  const normalized = normalizeIntentResponse({
+    success: false,
+    status: 'failed',
+    mode: 'agent_wallet',
+    blockedReason: 'EXECUTION_WALLET_MISMATCH',
+    blockedStage: 'routing',
+    error: `Funded wallet (${expectedWallet}) does not match execution wallet (${apiWallet}). Use --allow-wallet-mismatch to override.`,
+    preflightBlocked: true,
+    executionWalletAddress: apiWallet,
+  });
+  normalized.executionWalletAddress = apiWallet;
+  normalized.executionWalletPreflight = READ_FAST_PATH_PREFLIGHT;
+  return normalized;
+}
+
 async function executeSelfRun(ctx, flags, resolved, options) {
   const skipPreflight = Boolean(options?.skipPreflight);
   const blockedReasonCode = String(options?.blockedReasonCode || 'SELF_MODE_REQUIRES_BUILD_TX');

package/src/runtime/main.mjs

@@ -6,6 +6,7 @@ import {
   collectRootFlags,
   handleRootOnlyFlows,
   collectVersionFlagsFromArgv,
+  normalizeLegacyShortFlags,
 } from '../cli/program.mjs';
 import { createInitialRuntimeContext, applyFlagsToRuntimeContext } from './context.mjs';
 import { createProviderHints } from './providerHints.mjs';
@@ -87,6 +88,7 @@ export function createThirdfyAgentRuntime() {
     buildBitfinexOnboardingCommand: onboarding.buildBitfinexOnboardingCommand,
     inferBitfinexPermissionProfileFromAction: onboarding.inferBitfinexPermissionProfileFromAction,
     resolveAgentApiKey: payloads.resolveAgentApiKey,
+    resolveAgentKey: payloads.resolveAgentKey,
     loadEthers: ows.loadEthers,
     signAndBroadcastWithOws: ows.signAndBroadcastWithOws,
     readEffectBalances: ows.readEffectBalances,
@@ -154,7 +156,7 @@ export function createThirdfyAgentRuntime() {
     }
 
     try {
-      await cliProgram.parseAsync(process.argv, { from: 'node' });
+      await cliProgram.parseAsync(normalizeLegacyShortFlags(process.argv), { from: 'node' });
       const versionHandled = await handleRootOnlyFlows(cliProgram, rootFlowDeps);
       if (versionHandled) return;
     } catch (error) {

package/src/runtime/providerHints.mjs

@@ -1,9 +1,27 @@
+import { normalizeVenueProviderId } from '../core/venueBrand.mjs';
+
+/**
+ * Veranta (formerly Avantis) naming for the `avantis` / `avantis-vault` hints, static or from the
+ * capabilities manifest. Empty for every other provider.
+ */
+function verantaNamingFields(provider) {
+  if (provider !== 'avantis' && provider !== 'avantis-vault') return {};
+  const alias = provider === 'avantis' ? 'veranta' : 'veranta-vault';
+  return {
+    displayName: 'Veranta',
+    formerName: 'Avantis',
+    providerAliases: [alias],
+    actionNaming: `Veranta (formerly Avantis). Veranta action names (*_veranta_*) are canonical; Avantis names (*_avantis_*) still resolve. Provider id stays ${provider}; --provider ${alias} is an alias.`,
+  };
+}
+
 /**
  * Static and capabilities-backed provider discovery hints for CLI actions filtering.
  */
 export function createProviderHints({ getNegotiatedCapabilitiesCache }) {
   function getTradingProviderHint(providerId) {
-    const provider = String(providerId || '').trim().toLowerCase();
+    // `veranta` / `veranta-vault` resolve to the internal `avantis` / `avantis-vault` hints.
+    const provider = normalizeVenueProviderId(providerId || '');
     const manifestHint = getCachedProviderHintFromCapabilities(provider);
     const setupHints =
       manifestHint?.setupHints && typeof manifestHint.setupHints === 'object' ? manifestHint.setupHints : {};
@@ -206,68 +224,69 @@ export function createProviderHints({ getNegotiatedCapabilitiesCache }) {
     if (provider === 'avantis') {
       return {
         provider,
+        ...verantaNamingFields(provider),
         category: 'leveraged_perps',
-        canonicalWriteAction: 'place_avantis_perps_order',
+        canonicalWriteAction: 'place_veranta_perps_order',
         readActions: [
-          'get_avantis_markets',
-          'get_avantis_pair',
-          'get_avantis_price',
-          'get_avantis_spread',
-          'get_avantis_positions',
-          'get_avantis_open_orders',
-          'get_avantis_allowance',
-          'get_avantis_delegation_status',
-          'get_avantis_funding_status',
-          'get_avantis_setup_status',
-          'get_avantis_onboarding_plan',
-          'get_avantis_builder_fee_status',
-          'get_avantis_referral_status',
-          'get_avantis_referral_stats',
+          'get_veranta_markets',
+          'get_veranta_pair',
+          'get_veranta_price',
+          'get_veranta_spread',
+          'get_veranta_positions',
+          'get_veranta_open_orders',
+          'get_veranta_allowance',
+          'get_veranta_delegation_status',
+          'get_veranta_funding_status',
+          'get_veranta_setup_status',
+          'get_veranta_onboarding_plan',
+          'get_veranta_builder_fee_status',
+          'get_veranta_referral_status',
+          'get_veranta_referral_stats',
         ],
         orderManagementActions: [
-          'place_avantis_perps_order',
-          'cancel_avantis_perps_order',
-          'close_avantis_position',
-          'update_avantis_tp_sl',
-          'cancel_avantis_tp_sl',
-          'place_avantis_twap_order',
-          'close_avantis_twap_order',
-          'cancel_avantis_twap_order',
-          'place_avantis_coin_perps_order',
-          'increase_avantis_coin_position',
-          'close_avantis_coin_position',
-          'place_avantis_mm_order',
-          'cancel_avantis_mm_order',
-          'get_avantis_open_orders',
-          'get_avantis_positions',
+          'place_veranta_perps_order',
+          'cancel_veranta_perps_order',
+          'close_veranta_position',
+          'update_veranta_tp_sl',
+          'cancel_veranta_tp_sl',
+          'place_veranta_twap_order',
+          'close_veranta_twap_order',
+          'cancel_veranta_twap_order',
+          'place_veranta_coin_perps_order',
+          'increase_veranta_coin_position',
+          'close_veranta_coin_position',
+          'place_veranta_mm_order',
+          'cancel_veranta_mm_order',
+          'get_veranta_open_orders',
+          'get_veranta_positions',
         ],
         setupActions: [
-          'get_avantis_funding_status',
-          'get_avantis_setup_status',
-          'get_avantis_onboarding_plan',
-          'prepare_avantis_onboarding',
-          'complete_avantis_onboarding',
-          'approve_avantis_builder_fee',
-          'revoke_avantis_builder_fee',
-          'set_avantis_referral_code',
-          'register_avantis_referral_code',
-          'claim_avantis_referral_rebate',
+          'get_veranta_funding_status',
+          'get_veranta_setup_status',
+          'get_veranta_onboarding_plan',
+          'prepare_veranta_onboarding',
+          'complete_veranta_onboarding',
+          'approve_veranta_builder_fee',
+          'revoke_veranta_builder_fee',
+          'set_veranta_referral_code',
+          'register_veranta_referral_code',
+          'claim_veranta_referral_rebate',
         ],
         statusActions: [
-          'get_avantis_funding_status',
-          'get_avantis_setup_status',
-          'get_avantis_builder_fee_status',
-          'get_avantis_delegation_status',
+          'get_veranta_funding_status',
+          'get_veranta_setup_status',
+          'get_veranta_builder_fee_status',
+          'get_veranta_delegation_status',
         ],
         recoveryActions: [
-          'get_avantis_positions',
-          'close_avantis_position',
+          'get_veranta_positions',
+          'close_veranta_position',
         ],
         decommissionExample:
-          'get_avantis_positions -> close_avantis_position -> withdraw-to-user on execution wallet (Base USDC)',
+          'get_veranta_positions -> close_veranta_position -> withdraw-to-user on execution wallet (Base USDC)',
         credentialType: 'avantis_delegate',
         credentialUx:
-          'Thirdfy mints and stores the encrypted Avantis delegate. CLI callers use Thirdfy auth only. Do not paste a private key.',
+          'Thirdfy mints and stores the encrypted Veranta delegate. CLI callers use Thirdfy auth only. Do not paste a private key.',
         recommendedFundingChainId: 8453,
         supportedFundingSourceChains: [
           { chainId: 8453, name: 'Base', path: 'native USDC in managed execution wallet (recommended)' },
@@ -283,32 +302,33 @@ export function createProviderHints({ getNegotiatedCapabilitiesCache }) {
         funding:
           'Fund the managed execution wallet on Base (8453) with native USDC. Minimum collateral follows the live catalog notional floor.',
         laneCompatibility:
-          'Use agent_wallet for solo managed-wallet onboarding and perps writes after avantis_delegate credential is stored. Use thirdfy or hybrid for delegated capital. Thirdfy builds EIP-712 intents; the delegate credential signs batched-market submissions. Relayer is default. Builder-fee collection stays unwired until Avantis supplies a fee-enabled template.',
+          'Use agent_wallet for solo managed-wallet onboarding and perps writes after avantis_delegate credential is stored. Use thirdfy or hybrid for delegated capital. Thirdfy builds EIP-712 intents; the delegate credential signs batched-market submissions. Relayer is default. Builder-fee collection stays unwired until Veranta supplies a fee-enabled template.',
         setupExample:
-          'actions --provider avantis -> get_avantis_funding_status -> complete_avantis_onboarding (agent_wallet on Base 8453) -> get_avantis_setup_status before place_avantis_perps_order. Do not call approve_avantis_builder_fee until setup status shows a wired template.',
+          'actions --provider veranta -> get_veranta_funding_status -> complete_veranta_onboarding (agent_wallet on Base 8453) -> get_veranta_setup_status before place_veranta_perps_order. Do not call approve_veranta_builder_fee until setup status shows a wired template.',
         example:
-          'thirdfy-agent actions --provider avantis && thirdfy-agent preflight --action place_avantis_perps_order --params \'{"pairIndex":0,"side":"long","collateralUsdc":10,"leverage":10,"orderType":"market"}\'',
+          'thirdfy-agent actions --provider veranta && thirdfy-agent preflight --action place_veranta_perps_order --params \'{"pairIndex":0,"side":"long","collateralUsdc":10,"leverage":10,"orderType":"market"}\'',
       };
     }
     if (provider === 'avantis-vault') {
       return {
         provider,
+        ...verantaNamingFields(provider),
         category: 'earn',
-        canonicalReadAction: 'get_avantis_vault_info',
-        canonicalWriteAction: 'deposit_avantis_vault',
-        readActions: ['get_avantis_vault_info', 'get_avantis_vault_position'],
+        canonicalReadAction: 'get_veranta_vault_info',
+        canonicalWriteAction: 'deposit_veranta_vault',
+        readActions: ['get_veranta_vault_info', 'get_veranta_vault_position'],
         orderManagementActions: [
-          'deposit_avantis_vault',
-          'request_avantis_vault_withdrawal',
-          'redeem_avantis_vault',
-          'claim_avantis_vault',
+          'deposit_veranta_vault',
+          'request_veranta_vault_withdrawal',
+          'redeem_veranta_vault',
+          'claim_veranta_vault',
         ],
         recommendedFundingChainId: 8453,
         supportedChains: [8453],
         funding: 'Fund the managed execution wallet on Base with native USDC before vault deposit.',
-        laneCompatibility: 'Avantis LP vault on Base. Use agent_wallet, thirdfy, or hybrid. Relayer is default.',
+        laneCompatibility: 'Veranta (formerly Avantis) LP vault on Base. Use agent_wallet, thirdfy, or hybrid. Relayer is default.',
         example:
-          'thirdfy-agent actions --provider avantis-vault && thirdfy-agent run --action get_avantis_vault_info --provider avantis-vault --json',
+          'thirdfy-agent actions --provider veranta-vault && thirdfy-agent run --action get_veranta_vault_info --provider veranta-vault --json',
       };
     }
     if (provider === 'bitfinex') {
@@ -901,12 +921,12 @@ export function createProviderHints({ getNegotiatedCapabilitiesCache }) {
   }
 
   function getCachedProviderHintFromCapabilities(provider) {
-    const normalizedProvider = String(provider || '').trim().toLowerCase();
+    const normalizedProvider = normalizeVenueProviderId(provider || '');
     if (!normalizedProvider) return null;
     const manifests = Array.isArray(getNegotiatedCapabilitiesCache()?.providers?.manifests)
       ? getNegotiatedCapabilitiesCache().providers.manifests
       : [];
-    const match = manifests.find((entry) => String(entry?.providerId || '').trim().toLowerCase() === normalizedProvider);
+    const match = manifests.find((entry) => normalizeVenueProviderId(entry?.providerId || '') === normalizedProvider);
     if (!match) return null;
     const canonicalWriteActions = {
       trading: 'swap',
@@ -958,13 +978,20 @@ export function createProviderHints({ getNegotiatedCapabilitiesCache }) {
       custodyMode: match.custodyMode || null,
       description: match.description || null,
       source: 'cli_capabilities_manifest',
+      ...verantaNamingFields(normalizedProvider),
       ...(match.setupHints && typeof match.setupHints === 'object' ? { setupHints: match.setupHints } : {}),
     };
   }
 
+  // Veranta hints carry `providerAliases`; show the public name in messages (`--provider veranta`).
+  function providerLabelForHint(providerHint) {
+    const alias = Array.isArray(providerHint?.providerAliases) ? providerHint.providerAliases[0] : null;
+    return alias || providerHint.provider;
+  }
+
   function formatProviderAmbiguousActionHint(providerHint) {
     if (!providerHint) return '';
-    const p = providerHint.provider;
+    const p = providerLabelForHint(providerHint);
     const w = providerHint.canonicalWriteAction;
     if (w) return ` Provider ${p} expects ${w}.`;
     return ` Provider ${p} did not declare a canonical write action in capabilities; run actions --provider ${p} first.`;
@@ -972,7 +999,7 @@ export function createProviderHints({ getNegotiatedCapabilitiesCache }) {
 
   function formatProviderUnknownActionHint(providerHint) {
     if (!providerHint) return '';
-    const p = providerHint.provider;
+    const p = providerLabelForHint(providerHint);
     const w = providerHint.canonicalWriteAction;
     if (w) return ` Provider ${p} expects ${w}; run actions --provider ${p} first.`;
     return ` Provider ${p} did not declare a canonical write action in capabilities; run actions --provider ${p} first.`;