@thirdfy/agent-cli 0.1.48 → 0.2.2

package/src/runtime/bitfinexProbe.mjs

@@ -0,0 +1,121 @@
+import { createHmac } from 'crypto';
+import { DEFAULT_BITFINEX_BASE_URL, BITFINEX_PERMISSION_PROFILES } from '../core/constants.mjs';
+import { createCliError } from '../core/envelope.mjs';
+import { requestJson, safeJsonParse } from '../core/http.mjs';
+export function createBitfinexProbe() {
+function parseBitfinexPermissionRows(rawData) {
+  const rows = Array.isArray(rawData) ? rawData : [];
+  const parsed = {};
+  for (const row of rows) {
+    if (!Array.isArray(row) || row.length < 3) continue;
+    const scope = String(row[0] || '').trim().toLowerCase();
+    if (!scope) continue;
+    const read = Number(row[1]) === 1 ? 1 : 0;
+    const write = Number(row[2]) === 1 ? 1 : 0;
+    parsed[scope] = { read, write };
+  }
+  return parsed;
+}
+
+function getMissingBitfinexScopes(scopePermissions, permissionProfile = 'funding') {
+  const profile = BITFINEX_PERMISSION_PROFILES[permissionProfile] || BITFINEX_PERMISSION_PROFILES.funding;
+  const missing = [];
+  for (const [scope, required] of Object.entries(profile.required)) {
+    const actual = scopePermissions[scope] || { read: 0, write: 0 };
+    if (actual.read < required.read || actual.write < required.write) {
+      missing.push({
+        scope,
+        required,
+        actual,
+      });
+    }
+  }
+  return missing;
+}
+
+async function probeBitfinexPermissions({ apiKey, apiSecret, permissionProfile = 'funding', timeoutMs, baseUrl }) {
+  const normalizedBaseUrl = String(baseUrl || DEFAULT_BITFINEX_BASE_URL).trim().replace(/\/+$/, '');
+  const apiPath = '/v2/auth/r/permissions';
+  const nonce = Date.now().toString();
+  const payload = '{}';
+  const signature = createHmac('sha384', String(apiSecret || ''))
+    .update(`/api${apiPath}${nonce}${payload}`)
+    .digest('hex');
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), Number(timeoutMs || DEFAULT_TIMEOUT_MS));
+  try {
+    const response = await fetch(`${normalizedBaseUrl}${apiPath}`, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'bfx-apikey': String(apiKey || ''),
+        'bfx-nonce': nonce,
+        'bfx-signature': signature,
+      },
+      body: payload,
+      signal: controller.signal,
+    });
+    const text = await response.text();
+    const parsed = text ? safeJsonParse(text) : {};
+    const bitfinexApiError =
+      Array.isArray(parsed) && String(parsed[0] || '').trim().toLowerCase() === 'error'
+        ? {
+            code: Number(parsed[1]) || null,
+            message: String(parsed[2] || 'Unknown Bitfinex API error'),
+          }
+        : parsed && typeof parsed === 'object' && String(parsed.event || '').trim().toLowerCase() === 'error'
+          ? {
+              code: Number(parsed.code) || null,
+              message: String(parsed.msg || parsed.message || 'Unknown Bitfinex API error'),
+            }
+          : null;
+    if (!response.ok) {
+      throw createCliError(
+        'BITFINEX_PERMISSIONS_PROBE_FAILED',
+        `Bitfinex permissions probe failed with HTTP ${response.status}. Verify API key/secret and key validity before onboarding.`,
+        { statusCode: response.status }
+      );
+    }
+    if (bitfinexApiError) {
+      throw createCliError(
+        'BITFINEX_PERMISSIONS_PROBE_FAILED',
+        `Bitfinex permissions probe failed: ${bitfinexApiError.message}. Verify API key/secret and key validity before onboarding.`,
+        { statusCode: response.status, bitfinexApiError }
+      );
+    }
+    const scopePermissions = parseBitfinexPermissionRows(parsed);
+    const missingScopes = getMissingBitfinexScopes(scopePermissions, permissionProfile);
+    if (missingScopes.length > 0) {
+      throw createCliError(
+        'BITFINEX_PERMISSION_SCOPE_MISSING',
+        `Bitfinex key is missing required scopes (${missingScopes
+          .map((entry) => entry.scope)
+          .join(', ')}). Enable the ${permissionProfile} profile scopes and retry onboarding.`,
+        { missingScopes, scopePermissions, permissionProfile }
+      );
+    }
+    return {
+      venue: 'bitfinex',
+      permissionProfile,
+      checked: true,
+      scopes: scopePermissions,
+      missingScopes: [],
+    };
+  } catch (error) {
+    if (error?.payload) throw error;
+    throw createCliError(
+      'BITFINEX_PERMISSIONS_PROBE_FAILED',
+      `Could not verify Bitfinex key permissions. ${String(error?.message || 'Unknown probe error')}`,
+      {}
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+  return {
+    parseBitfinexPermissionRows,
+    getMissingBitfinexScopes,
+    probeBitfinexPermissions,
+  };
+}

package/src/runtime/context.mjs

@@ -0,0 +1,28 @@
+import { DEFAULT_API_BASE, DEFAULT_TIMEOUT_MS } from '../core/constants.mjs';
+import { loadEnvFile } from '../core/args.mjs';
+import { resolveProfileState } from '../core/context.mjs';
+
+export function createInitialRuntimeContext() {
+  return {
+    apiBase: DEFAULT_API_BASE,
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+    jsonMode: false,
+    verbose: false,
+    negotiatedCapabilitiesCache: null,
+  };
+}
+
+export function applyFlagsToRuntimeContext(context, flags) {
+  if (flags.env) loadEnvFile(flags.env);
+  context.apiBase = String(flags.apiBase || process.env.THIRDFY_API_BASE || DEFAULT_API_BASE).replace(/\/+$/, '');
+  const timeoutMs = Number(flags.timeout || process.env.THIRDFY_CLI_TIMEOUT_MS || DEFAULT_TIMEOUT_MS);
+  context.timeoutMs = Number.isFinite(timeoutMs) ? timeoutMs : DEFAULT_TIMEOUT_MS;
+  context.jsonMode = Boolean(flags.json);
+  context.verbose = Boolean(flags.verbose);
+  const profileState = resolveProfileState(flags);
+  context.profile = profileState.profile;
+  context.runMode = profileState.runMode;
+  context.custodyMode = profileState.custodyMode;
+  context.profileConfigPath = profileState.configPath;
+  return context;
+}

package/src/runtime/createThirdfyAgentRuntime.mjs

@@ -0,0 +1,2 @@
+/** @deprecated Import from `./main.mjs` or `./index.mjs`. Kept for backward-compatible deep imports. */
+export { createThirdfyAgentRuntime } from './main.mjs';

package/src/runtime/errors.mjs

@@ -0,0 +1,3 @@
+export function isCommanderCliError(err) {
+  return Boolean(err && typeof err === 'object' && String(err.code || '').startsWith('commander.'));
+}

package/src/runtime/execution/amounts.mjs

@@ -0,0 +1,193 @@
+import { parseJsonFlag } from '../../core/args.mjs';
+import { createCliError } from '../../core/envelope.mjs';
+export function createExecutionAmounts() {
+function shouldApplySwapAmountContract(actionName) {
+  const action = String(actionName || '').trim().toLowerCase();
+  return action === 'swap' || /(^|:|-)swap$/.test(action);
+}
+
+function normalizeIntegerRawAmount(input, code = 'AMOUNT_UNIT_INVALID') {
+  const raw = String(input ?? '').trim();
+  if (!/^\d+$/.test(raw)) {
+    throw createCliError(code, 'amountInRaw must be an integer base-unit string (example: "1000000").');
+  }
+  return raw;
+}
+
+function decimalToRawUnits(amountHuman, decimals) {
+  const s = String(amountHuman ?? '').trim();
+  if (!/^\d+(\.\d+)?$/.test(s)) {
+    throw createCliError('AMOUNT_UNIT_INVALID', 'amountInHuman must be a decimal string (example: "100.5").');
+  }
+  const [whole, frac = ''] = s.split('.');
+  if (decimals === 0) {
+    if (frac && /[1-9]/.test(frac)) {
+      throw createCliError(
+        'AMOUNT_PRECISION_EXCESS',
+        'amountInHuman has fractional digits but tokenInDecimals is 0 (example: use "2" not "2.5").'
+      );
+    }
+  } else if (frac.length > decimals && /[1-9]/.test(frac.slice(decimals))) {
+    throw createCliError(
+      'AMOUNT_PRECISION_EXCESS',
+      `amountInHuman has more than ${decimals} fractional digit(s) for tokenInDecimals; round or use amountInRaw.`
+    );
+  }
+  const fracNorm = (frac + '0'.repeat(decimals)).slice(0, decimals);
+  const wholePart = BigInt(whole || '0') * 10n ** BigInt(decimals);
+  const fracPart = BigInt(fracNorm || '0');
+  return (wholePart + fracPart).toString();
+}
+
+function rawUnitsToDecimalString(amountRaw, decimals) {
+  const raw = normalizeIntegerRawAmount(amountRaw);
+  const base = 10n ** BigInt(decimals);
+  const n = BigInt(raw);
+  const whole = n / base;
+  const frac = n % base;
+  if (decimals === 0 || frac === 0n) return whole.toString();
+  const fracText = frac.toString().padStart(decimals, '0').replace(/0+$/, '');
+  return `${whole.toString()}.${fracText}`;
+}
+
+function normalizeSwapAmountContract(params) {
+  const hasRaw = params.amountInRaw !== undefined && params.amountInRaw !== null && String(params.amountInRaw).trim() !== '';
+  const hasHuman = params.amountInHuman !== undefined && params.amountInHuman !== null && String(params.amountInHuman).trim() !== '';
+  const hasLegacy = params.amountIn !== undefined && params.amountIn !== null && String(params.amountIn).trim() !== '';
+  const populated = [hasRaw, hasHuman, hasLegacy].filter(Boolean).length;
+  if (populated === 0) {
+    throw createCliError(
+      'AMOUNT_UNIT_MISSING',
+      'Missing swap amount: provide one of amountInRaw, amountInHuman, or legacy amountIn.'
+    );
+  }
+  if (populated > 1) {
+    throw createCliError(
+      'AMOUNT_UNIT_AMBIGUOUS',
+      'Provide exactly one of amountInRaw, amountInHuman, or legacy amountIn.'
+    );
+  }
+
+  if (hasRaw) {
+    const amountInRaw = normalizeIntegerRawAmount(params.amountInRaw);
+    const hasDecimals =
+      params.tokenInDecimals !== undefined &&
+      params.tokenInDecimals !== null &&
+      String(params.tokenInDecimals).trim() !== '';
+    if (!hasDecimals) {
+      throw createCliError(
+        'AMOUNT_UNIT_DECIMALS_REQUIRED',
+        'amountInRaw requires tokenInDecimals (integer 0-36).'
+      );
+    }
+    const decimals = Number(params.tokenInDecimals);
+    if (!Number.isInteger(decimals) || decimals < 0 || decimals > 36) {
+      throw createCliError(
+        'AMOUNT_UNIT_DECIMALS_REQUIRED',
+        'amountInRaw requires tokenInDecimals (integer 0-36).'
+      );
+    }
+    const amountInHuman = rawUnitsToDecimalString(amountInRaw, decimals);
+    return {
+      params: {
+        ...params,
+        amountInRaw,
+        amountIn: amountInHuman,
+        tokenInDecimals: decimals,
+      },
+      swapInput: {
+        amountInRaw,
+        amountInHuman,
+        tokenInDecimals: decimals,
+        unitSource: 'raw',
+      },
+    };
+  }
+
+  if (hasLegacy) {
+    const amountInHuman = String(params.amountIn).trim();
+    if (!/^\d+(\.\d+)?$/.test(amountInHuman)) {
+      throw createCliError(
+        'AMOUNT_UNIT_INVALID',
+        'Legacy swap amountIn must be a decimal token-unit string (example: "1.25"). For base units use amountInRaw with tokenInDecimals.'
+      );
+    }
+    return {
+      params: {
+        ...params,
+        amountIn: amountInHuman,
+      },
+      swapInput: {
+        amountInRaw: null,
+        amountInHuman,
+        tokenInDecimals: null,
+        unitSource: 'legacy_human',
+      },
+    };
+  }
+
+  const hasDecimals =
+    params.tokenInDecimals !== undefined &&
+    params.tokenInDecimals !== null &&
+    String(params.tokenInDecimals).trim() !== '';
+  if (!hasDecimals) {
+    throw createCliError(
+      'AMOUNT_UNIT_DECIMALS_REQUIRED',
+      'amountInHuman requires tokenInDecimals (integer 0-36).'
+    );
+  }
+  const decimals = Number(params.tokenInDecimals);
+  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 36) {
+    throw createCliError(
+      'AMOUNT_UNIT_DECIMALS_REQUIRED',
+      'amountInHuman requires tokenInDecimals (integer 0-36).'
+    );
+  }
+  const amountInHuman = String(params.amountInHuman).trim();
+  const amountInRaw = decimalToRawUnits(amountInHuman, decimals);
+  return {
+    params: {
+      ...params,
+      amountInHuman,
+      amountInRaw,
+      amountIn: amountInHuman,
+      tokenInDecimals: decimals,
+    },
+    swapInput: {
+      amountInRaw,
+      amountInHuman,
+      tokenInDecimals: decimals,
+      unitSource: 'human',
+    },
+  };
+}
+
+function prepareActionParamsForFlags(flags, resolvedAction) {
+  const parsedParams = parseJsonFlag(flags, 'params');
+  if (!shouldApplySwapAmountContract(resolvedAction)) {
+    flags.__preparedParams = parsedParams;
+    flags.__swapInput = null;
+    return;
+  }
+  const normalized = normalizeSwapAmountContract(parsedParams);
+  flags.__preparedParams = normalized.params;
+  flags.__swapInput = normalized.swapInput;
+}
+
+function getPreparedParams(flags) {
+  if (flags.__preparedParams && typeof flags.__preparedParams === 'object') {
+    return flags.__preparedParams;
+  }
+  return parseJsonFlag(flags, 'params');
+}
+
+  return {
+    shouldApplySwapAmountContract,
+    normalizeIntegerRawAmount,
+    decimalToRawUnits,
+    rawUnitsToDecimalString,
+    normalizeSwapAmountContract,
+    prepareActionParamsForFlags,
+    getPreparedParams,
+  };
+}

package/src/runtime/execution/lanes.mjs

@@ -0,0 +1,75 @@
+import { createCliError } from '../../core/envelope.mjs';
+export function createExecutionLanes() {
+const OFFCHAIN_VENUE_ORDER_ACTIONS = new Set([
+  'place_hyperliquid_perps_order',
+  'place-hyperliquid-perps-order',
+  'cancel_hyperliquid_perps_order',
+  'cancel-hyperliquid-perps-order',
+  'place_polymarket_order',
+  'place-polymarket-order',
+]);
+function enforceOffchainVenueLaneCompatibility(action, runMode) {
+  const normalizedAction = String(action || '').trim().toLowerCase();
+  if (runMode !== 'self' || !OFFCHAIN_VENUE_ORDER_ACTIONS.has(normalizedAction)) return;
+  throw createCliError(
+    'OFFCHAIN_VENUE_ORDER_SELF_UNSUPPORTED',
+    'Polymarket CLOB and Hyperliquid perps orders 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',
+    }
+  );
+}
+
+function resolveChainSupport(capabilities, chainId, runMode) {
+  const chains = Array.isArray(capabilities?.chains) ? capabilities.chains : [];
+  if (!chainId) return { chainId: null, supported: null };
+  const match = chains.find((entry) => Number(entry.chainId) === Number(chainId));
+  if (!match) {
+    return { chainId, supported: false, reason: 'chain_not_advertised_by_api' };
+  }
+  const lanes = Array.isArray(match.supportedExecutionLanes) ? match.supportedExecutionLanes : [];
+  return {
+    chainId,
+    supported: lanes.includes(runMode),
+    runMode,
+    chainKey: match.chainKey || null,
+    displayName: match.displayName || null,
+  };
+}
+
+function enforceChainCompatibility(capabilities, flags, runMode) {
+  const chainId = Number(flags.chainId || 0) || undefined;
+  if (!chainId) return;
+  if (!capabilities || !Array.isArray(capabilities.chains)) return;
+  const support = resolveChainSupport(capabilities, chainId, runMode);
+  if (support?.supported === false) {
+    throw new Error(
+      `Chain ${chainId} is not advertised as compatible with run-mode=${runMode}. Check \`thirdfy-agent actions --chain-id ${chainId}\`.`
+    );
+  }
+}
+
+function shouldUseBuildTxExecution(runMode, resolved) {
+  if (runMode !== 'self' && runMode !== 'hybrid') return false;
+  const meta = resolved?.resolvedActionMeta || null;
+  if (!meta || typeof meta !== 'object') return true;
+  if (meta.supportsBuildTx === false) return false;
+  return true;
+}
+
+function shouldUseBuildTxPreflight(runMode, resolved) {
+  if (runMode !== 'self') return false;
+  const meta = resolved?.resolvedActionMeta || null;
+  if (!meta || typeof meta !== 'object') return false;
+  return meta.supportsExecuteIntent === false && meta.supportsBuildTx === true;
+}
+
+  return {
+    enforceOffchainVenueLaneCompatibility,
+    resolveChainSupport,
+    enforceChainCompatibility,
+    shouldUseBuildTxExecution,
+    shouldUseBuildTxPreflight,
+  };
+}

package/src/runtime/execution/payloads.mjs

@@ -0,0 +1,148 @@
+import { randomUUID } from 'crypto';
+import { requireFlag, parseJsonFlag } from '../../core/args.mjs';
+import { loadProfileConfig } from '../../core/context.mjs';
+import { createCliError } from '../../core/envelope.mjs';
+import { normalizeRunMode, normalizeManagedRunMode, normalizeHybridWalletMode } from '../../core/runMode.mjs';
+export function createExecutionPayloads({ getPreparedParams, rawUnitsToDecimalString }) {
+function buildBuildTxPayload(flags, resolvedAction) {
+  const runMode = String(flags.runMode || '').trim().toLowerCase() || 'self';
+  const payload = {
+    agentApiKey: resolveAgentApiKey(flags, runMode),
+    action: String(resolvedAction || requireFlag(flags, 'action', 'Missing --action')).trim(),
+    params: getPreparedParams(flags),
+  };
+  if (flags.chainId) payload.chainId = Number(flags.chainId);
+  if (flags.walletAddress) payload.walletAddress = String(flags.walletAddress).trim();
+  return payload;
+}
+
+function resolveEffectiveUserDid(flags) {
+  const explicit = String(flags.userDid || '').trim();
+  if (explicit) return explicit;
+  const envUserDid = String(process.env.THIRDFY_USER_DID || '').trim();
+  if (envUserDid) return envUserDid;
+  const config = loadProfileConfig();
+  return String(config?.wallets?.userDid || config?.identity?.userDid || '').trim();
+}
+
+function buildManagedExecutePayload(flags, options) {
+  const runMode = String(options.runMode || flags.runMode || 'agent_wallet').trim().toLowerCase();
+  const params = getPreparedParams(flags);
+  const managedParams = { ...params };
+  if (flags.__swapInput?.unitSource === 'human' && flags.__swapInput.amountInHuman) {
+    delete managedParams.amountInRaw;
+    delete managedParams.amountInHuman;
+    delete managedParams.tokenInDecimals;
+    managedParams.amountIn = flags.__swapInput.amountInHuman;
+  } else if (flags.__swapInput?.unitSource === 'raw' && flags.__swapInput.amountInRaw) {
+    const decimals = flags.__swapInput.tokenInDecimals;
+    delete managedParams.amountInHuman;
+    delete managedParams.amountInRaw;
+    delete managedParams.tokenInDecimals;
+    if (!Number.isInteger(decimals) || decimals < 0 || decimals > 36) {
+      throw createCliError(
+        'AMOUNT_UNIT_DECIMALS_REQUIRED',
+        'amountInRaw requires tokenInDecimals (integer 0-36).'
+      );
+    }
+    managedParams.amountIn = rawUnitsToDecimalString(flags.__swapInput.amountInRaw, decimals);
+  } else if (flags.__swapInput?.unitSource === 'legacy_human' && flags.__swapInput.amountInHuman) {
+    delete managedParams.amountInRaw;
+    delete managedParams.amountInHuman;
+    delete managedParams.tokenInDecimals;
+    managedParams.amountIn = flags.__swapInput.amountInHuman;
+  }
+  const payload = {
+    agentApiKey: resolveAgentApiKey(flags, runMode),
+    action: String(options.resolvedAction || requireFlag(flags, 'action', 'Missing --action')).trim(),
+    userDid: resolveEffectiveUserDid(flags),
+    params: managedParams,
+    chainId: Number(flags.chainId || 8453),
+    executionStrategy: {
+      runMode,
+      mirrorOnly: false,
+    },
+  };
+  if (!payload.userDid) {
+    throw createCliError(
+      'MISSING_USER_DID',
+      'Managed wallet execution requires --user-did, THIRDFY_USER_DID, or a saved userDid from `thirdfy-agent login email`.'
+    );
+  }
+  if (flags.estimatedAmountUsd) payload.estimatedAmountUsd = Number(flags.estimatedAmountUsd);
+  if (options.forceIdempotency) {
+    payload.executionIdempotencyKey = String(
+      flags.idempotencyKey || `cli:walletExecute:${payload.action}:${Date.now()}:${randomUUID()}`
+    );
+  } else if (flags.idempotencyKey) {
+    payload.executionIdempotencyKey = String(flags.idempotencyKey);
+  }
+  return payload;
+}
+
+function resolveTokenInForFunding(params) {
+  if (!params || typeof params !== 'object') return '';
+  const tokenIn = String(params.tokenIn || params.tokenAddress || params.token || '').trim();
+  return tokenIn;
+}
+
+function buildIntentPayload(flags, options) {
+  const runMode = String(options.runMode || flags.runMode || '').trim().toLowerCase() || 'thirdfy';
+  const payload = {
+    agentApiKey: resolveAgentApiKey(flags, runMode),
+    action: String(options.resolvedAction || requireFlag(flags, 'action', 'Missing --action')).trim(),
+    params: getPreparedParams(flags),
+  };
+  if (flags.catalog) payload.catalog = String(flags.catalog).trim();
+  if (flags.chainId) payload.chainId = Number(flags.chainId);
+  if (flags.estimatedAmountUsd) payload.estimatedAmountUsd = Number(flags.estimatedAmountUsd);
+  const userDid = resolveEffectiveUserDid(flags);
+  if (flags.userDid || (options.validationOnly && (runMode === 'agent_wallet' || (runMode === 'hybrid' && options.mirrorOnly)))) {
+    if (userDid) payload.userDid = userDid;
+  }
+  if (options.validationOnly) payload.executionLane = 'validation_only';
+  if (flags.executionScope) {
+    payload.executionScope = String(flags.executionScope).trim();
+  } else if (options.validationOnly && (runMode === 'agent_wallet' || (runMode === 'hybrid' && options.mirrorOnly))) {
+    payload.executionScope = 'solo_owner_mirror';
+  }
+  if (options.runMode) {
+    payload.executionStrategy = {
+      runMode: String(options.runMode),
+      mirrorOnly: Boolean(options.mirrorOnly),
+      ...(options.hybridWalletMode ? { hybridWalletMode: String(options.hybridWalletMode) } : {}),
+    };
+  }
+  if (options.forceIdempotency) {
+    payload.idempotencyKey = String(flags.idempotencyKey || `cli:${payload.action}:${Date.now()}:${randomUUID()}`);
+  } else if (flags.idempotencyKey) {
+    payload.idempotencyKey = String(flags.idempotencyKey);
+  }
+  return payload;
+}
+
+function resolveAgentApiKey(flags, runMode) {
+  const explicit = String(flags.agentApiKey || '').trim();
+  if (explicit) return explicit;
+  const envKey = String(process.env.THIRDFY_AGENT_API_KEY || '').trim();
+  if (envKey) return envKey;
+  const config = loadProfileConfig();
+  const configKey = String(config?.agent?.apiKey || '').trim();
+  if (configKey) return configKey;
+  if (runMode === 'self') {
+    throw new Error(
+      'SELF_OPEN_DISABLED: self mode without agent identity is not enabled on this API yet. Set --agent-api-key, THIRDFY_AGENT_API_KEY, or login/config default.'
+    );
+  }
+  throw new Error('Missing --agent-api-key (or THIRDFY_AGENT_API_KEY / config.agent.apiKey)');
+}
+
+  return {
+    buildBuildTxPayload,
+    resolveEffectiveUserDid,
+    buildManagedExecutePayload,
+    resolveTokenInForFunding,
+    buildIntentPayload,
+    resolveAgentApiKey,
+  };
+}