read.asset_manager.intents

Instructions

Implementation Reference

• src/tools/read/asset-managers.ts:140-203 (handler)

  Registration and handler function for the 'read.asset_manager.intents' tool. Calls server.registerTool with the name, schema, and an async handler that filters INTENTS by chain_id, hydrates dex_protocol values for the chain, and returns the list of automations with usage instructions.

  export function registerAssetManagerTools(server: McpServer) {
    server.registerTool(
      "read.asset_manager.intents",
      {
        annotations: {
          title: "List Available Automations",
          readOnlyHint: true,
          destructiveHint: false,
          idempotentHint: true,
          openWorldHint: false,
        },
        description:
          "List all available automation intents with their tool names, required parameters, and supported chains. Use this to discover which automations can be configured and what each one does. Each intent has a corresponding write.asset_manager.{id} tool that returns encoded args. To apply automations, call the intent tools then pass the combined result to write.account.set_asset_managers. All intent tools accept enabled=false to disable. Multiple intents can be combined by merging their returned arrays into a single set_asset_managers call.",
        inputSchema: {
          chain_id: z
            .number()
            .optional()
            .describe("Filter to automations available on this chain. Omit to see all."),
        },
        outputSchema: IntentsListOutput,
      },
      async (params) => {
        try {
          let filtered = INTENTS;
          if (params.chain_id !== undefined) {
            const validChainId = validateChainId(params.chain_id);
            const chainDexProtocols = getChainDexProtocols(validChainId);
            filtered = INTENTS.filter((i) => i.chains.includes(validChainId)).map((intent) => ({
              ...intent,
              required_params: intent.required_params.map((p) =>
                p.name === "dex_protocol" ? { ...p, values: chainDexProtocols } : p,
              ),
            }));
          }
  
          const result = {
            automations: filtered,
            shared_params: ["enabled (boolean, default true)", "chain_id (number, default 8453)"],
            usage:
              "1. Call the intent tool (e.g. write.asset_manager.rebalancer) with enabled + chain_id to get encoded args. 2. Optionally merge arrays from multiple intent calls. 3. Pass to write.account.set_asset_managers to build the unsigned tx.",
          };
          return {
            content: [
              {
                type: "text" as const,
                text: JSON.stringify(result, null, 2),
              },
            ],
            structuredContent: result,
          };
        } catch (err) {
          return {
            content: [
              {
                type: "text" as const,
                text: `Error: ${err instanceof Error ? err.message : String(err)}`,
              },
            ],
            isError: true,
          };
        }
      },
    );
  }

• src/tools/output-schemas.ts:154-158 (schema)

  Output schema (IntentsListOutput) defining the shape of the response: automations array, shared_params array, and usage string.

  export const IntentsListOutput = z.object({
    automations: z.array(z.record(z.unknown())),
    shared_params: z.array(z.string()),
    usage: z.string(),
  });

• src/tools/read/asset-managers.ts:153-158 (schema)

  Input schema: optional chain_id number used to filter automations by chain.

  inputSchema: {
    chain_id: z
      .number()
      .optional()
      .describe("Filter to automations available on this chain. Omit to see all."),
  },

• src/tools/read/asset-managers.ts:43-44 (helper)

  Chain constants (ALL_CHAINS = [8453, 130, 10], BASE_ONLY = [8453]) used to populate which chains each automation supports.

  const ALL_CHAINS: ChainId[] = [8453, 130, 10];
  const BASE_ONLY: ChainId[] = [8453];

• src/tools/index.ts:11-47 (registration)

  Import and registration call (registerAssetManagerTools) that wires the tool into the MCP server.

  import { registerAssetManagerTools } from "./read/asset-managers.js";
  import { registerCreateTool } from "./write/account/create.js";
  import { registerDepositTool } from "./write/account/deposit.js";
  import { registerWithdrawTool } from "./write/account/withdraw.js";
  import { registerBorrowTool } from "./write/account/borrow.js";
  import { registerRepayTool } from "./write/account/repay.js";
  import { registerApproveTool } from "./write/wallet/approve.js";
  import { registerPoolDepositTool } from "./write/pool/deposit.js";
  import { registerPoolRedeemTool } from "./write/pool/redeem.js";
  import { registerRebalancerTool } from "./write/asset-managers/rebalancer.js";
  import { registerCompounderTools } from "./write/asset-managers/compounder.js";
  import { registerYieldClaimerTools } from "./write/asset-managers/yield-claimer.js";
  import { registerCowSwapperTool } from "./write/asset-managers/cow-swapper.js";
  import { registerMerklOperatorTool } from "./write/asset-managers/merkl-operator.js";
  import { registerSetAssetManagersTool } from "./write/asset-managers/set-asset-managers.js";
  import { registerSendTool } from "./dev/send.js";
  import { registerAddLiquidityTool } from "./write/account/add-liquidity.js";
  import { registerRemoveLiquidityTool } from "./write/account/remove-liquidity.js";
  import { registerSwapTool } from "./write/account/swap.js";
  import { registerDeleverageTool } from "./write/account/deleverage.js";
  import { registerStakeTool } from "./write/account/stake.js";
  import { registerCloseTool } from "./write/account/close.js";
  
  export function registerAllTools(
    server: McpServer,
    api: ArcadiaApiClient,
    chains: Record<ChainId, ChainConfig>,
  ) {
    // Read tools
    registerAccountTools(server, api, chains);
    registerPoolTools(server, api);
    registerAssetTools(server, api);
    registerStrategyTools(server, api);
    registerPointsTools(server, api);
    registerGuideTools(server);
    registerWalletTools(server, chains, api);
    registerAssetManagerTools(server);