basileus-agentkit-plugin 0.1.0 → 0.1.1

package/README.md

@@ -0,0 +1,97 @@
+# basileus-agentkit-plugin
+
+[Coinbase AgentKit](https://github.com/coinbase/agentkit) plugin for [Basileus](https://github.com/RezaRahemtola/ETHDenver-2026) — build autonomous onchain agents with [Aleph Cloud](https://aleph.cloud), x402 payment tracking, and predefined action providers.
+
+## Features
+
+- **Aleph Publisher** — publish agent activity (reasoning, tool calls, transactions) to Aleph Cloud for full transparency
+- **x402 Tracker** — intercept HTTP 402 payments and track transaction hashes
+- **Agent Loop** — BlockRun AI tool-calling loop with auto conversion of AgentKit actions to BlockRun tools.
+- **Summarizer** — summarize agent phases into short, human-readable activity logs
+- **Wallet** — create an AgentKit wallet with Basileus' ERC-8021 builder code attribution
+- **Compound Actions** — fixed Compound Finance action provider (supply, withdraw, portfolio)
+- **Aleph Actions** — VPS computing costs information, balance tracking and swaps action provider for built-in self-funding of computing costs
+
+## Install
+
+```bash
+npm install basileus-agentkit-plugin
+```
+
+Peer dependencies (install alongside):
+
+```bash
+npm install @blockrun/llm @coinbase/agentkit viem
+```
+
+## Usage
+
+```ts
+import {
+  AlephPublisher,
+  installX402Tracker,
+  actionsToTools,
+  runAgentLoop,
+  createLLMClient,
+  createAgentWallet,
+} from "basileus-agentkit-plugin";
+```
+
+### Sub-path imports
+
+```ts
+// Individual modules
+import { AlephPublisher } from "basileus-agentkit-plugin/aleph";
+import { installX402Tracker } from "basileus-agentkit-plugin/x402";
+import { runAgentLoop } from "basileus-agentkit-plugin/agent-loop";
+import { actionsToTools } from "basileus-agentkit-plugin/tools";
+import { summarizePhase } from "basileus-agentkit-plugin/summarizer";
+import { createAgentWallet } from "basileus-agentkit-plugin/wallet";
+
+// Action providers
+import { createAlephActionProvider } from "basileus-agentkit-plugin/actions/aleph";
+import { compoundFixedProvider } from "basileus-agentkit-plugin/actions/compound";
+```
+
+### Quick start
+
+```ts
+import { createAgentWallet, AlephPublisher, actionsToTools, runAgentLoop, createLLMClient, installX402Tracker, drainX402TxHashes } from "basileus-agentkit-plugin";
+import { createAlephActionProvider } from "basileus-agentkit-plugin/actions/aleph";
+import { compoundFixedProvider } from "basileus-agentkit-plugin/actions/compound";
+
+// 1. Wallet
+const wallet = await createAgentWallet(process.env.PRIVATE_KEY!, "base");
+
+// 2. x402 tracking
+installX402Tracker();
+
+// 3. Action providers → tools
+const providers = [compoundFixedProvider, createAlephActionProvider()];
+const { tools, executeTool } = actionsToTools(providers, wallet);
+
+// 4. Aleph publisher
+const publisher = new AlephPublisher(process.env.PRIVATE_KEY!);
+await publisher.init();
+
+// 5. Run agent loop
+const client = createLLMClient(process.env.BLOCKRUN_API_KEY!);
+const result = await runAgentLoop(client, "What is my Compound portfolio?", tools, "You are a DeFi agent.", [], executeTool);
+
+// 6. Publish activity
+const txHashes = drainX402TxHashes();
+await publisher.publish({ phase: "portfolio-check", response: result.response, toolExecutions: result.toolExecutions, txHashes });
+```
+
+## License
+
+MIT
+
+<div align="center">
+  <h2>Made with ❤️ by</h2>
+  <a href="https://github.com/RezaRahemtola">
+    <img src="https://github.com/RezaRahemtola.png?size=85" width=85/>
+    <br>
+    <span>Reza Rahemtola</span>
+  </a>
+</div>

package/package.json

@@ -1,12 +1,33 @@
 {
   "name": "basileus-agentkit-plugin",
-  "version": "0.1.0",
+  "version": "0.1.1",
+  "description": "Coinbase AgentKit plugin for Basileus — build autonomous onchain agents with Aleph Cloud, x402 payment tracking, and predefined action providers",
   "type": "module",
+  "license": "MIT",
+  "author": "Basileus",
+  "homepage": "https://github.com/RezaRahemtola/ETHDenver-2026/tree/main/basileus-agentkit-plugin#readme",
   "repository": {
     "type": "git",
     "url": "https://github.com/RezaRahemtola/ETHDenver-2026",
     "directory": "basileus-agentkit-plugin"
   },
+  "bugs": {
+    "url": "https://github.com/RezaRahemtola/ETHDenver-2026/issues"
+  },
+  "keywords": [
+    "agentkit",
+    "coinbase",
+    "base",
+    "blockchain",
+    "agent",
+    "aleph",
+    "x402",
+    "basileus"
+  ],
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {

package/.nvmrc

@@ -1 +0,0 @@
-v24

package/.prettierrc

@@ -1,7 +0,0 @@
-{
-  "semi": true,
-  "singleQuote": false,
-  "trailingComma": "all",
-  "printWidth": 100,
-  "tabWidth": 2
-}

package/eslint.config.js

@@ -1,26 +0,0 @@
-import tseslint from "@typescript-eslint/eslint-plugin";
-import tsparser from "@typescript-eslint/parser";
-
-export default [
-  {
-    files: ["src/**/*.ts"],
-    languageOptions: {
-      parser: tsparser,
-      parserOptions: {
-        ecmaVersion: "latest",
-        sourceType: "module",
-      },
-    },
-    plugins: {
-      "@typescript-eslint": tseslint,
-    },
-    rules: {
-      ...tseslint.configs.recommended.rules,
-      "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
-      "@typescript-eslint/no-explicit-any": "warn",
-    },
-  },
-  {
-    ignores: ["dist/"],
-  },
-];

package/src/actions/aleph.ts

@@ -1,145 +0,0 @@
-import { z } from "zod";
-import {
-  customActionProvider,
-  EvmWalletProvider,
-  SuperfluidQueryActionProvider,
-} from "@coinbase/agentkit";
-import { createPublicClient, formatUnits, http, parseEther, encodeFunctionData } from "viem";
-import { base } from "viem/chains";
-import {
-  ALEPH_ADDRESS,
-  WETH_ADDRESS,
-  UNISWAP_ROUTER,
-  UNISWAP_ALEPH_POOL,
-  uniswapV3PoolAbi,
-  uniswapRouterAbi,
-} from "./constants.js";
-
-const balanceOfAbi = [
-  {
-    inputs: [{ name: "account", type: "address" }],
-    name: "balanceOf",
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-] as const;
-
-export function createAlephActionProvider(rpcUrl?: string) {
-  const publicClient = createPublicClient({
-    chain: base,
-    transport: http(rpcUrl),
-  });
-
-  return customActionProvider<EvmWalletProvider>([
-    {
-      name: "get_aleph_info",
-      description:
-        "Get your current ALEPH balance, hourly consumption rate, estimated hours of compute left, ETH balance, and ALEPH/ETH price. Use this to decide whether you need to buy more ALEPH.",
-      schema: z.object({}),
-      invoke: async (walletProvider: EvmWalletProvider, _args: unknown) => {
-        try {
-          const address = walletProvider.getAddress() as `0x${string}`;
-
-          const sfQuery = new SuperfluidQueryActionProvider();
-          const streamsResult = await sfQuery.queryStreams(walletProvider);
-
-          let alephPerHour = 0;
-          try {
-            const jsonStr = streamsResult.replace("Current outflows are ", "");
-            const outflows = JSON.parse(jsonStr) as Array<{
-              currentFlowRate: string;
-              token: { symbol: string };
-              receiver: { id: string };
-            }>;
-            const alephOutflows = outflows.filter((o) =>
-              o.token.symbol.toLowerCase().includes("aleph"),
-            );
-            const totalFlowRate = alephOutflows.reduce(
-              (sum, o) => sum + BigInt(o.currentFlowRate),
-              0n,
-            );
-            alephPerHour = parseFloat(formatUnits(totalFlowRate * 3600n, 18));
-          } catch {
-            // No outflows or parse error
-          }
-
-          const rawBalance = await publicClient.readContract({
-            address: ALEPH_ADDRESS,
-            abi: balanceOfAbi,
-            functionName: "balanceOf",
-            args: [address],
-          });
-          const alephBalance = parseFloat(formatUnits(rawBalance, 18));
-
-          let hoursLeft = 1000000;
-          if (alephPerHour > 0) {
-            hoursLeft = Math.round(alephBalance / alephPerHour);
-          }
-
-          const ethBalanceWei = await publicClient.getBalance({ address });
-          const ethBalance = parseFloat(formatUnits(ethBalanceWei, 18));
-
-          const slot0 = await publicClient.readContract({
-            address: UNISWAP_ALEPH_POOL,
-            abi: uniswapV3PoolAbi,
-            functionName: "slot0",
-          });
-          const sqrtPriceX96 = slot0[0];
-          const price = Number(sqrtPriceX96) / 2 ** 96;
-          const alephPerEth = price * price;
-
-          return JSON.stringify({
-            aleph_balance: Math.round(alephBalance * 1000) / 1000,
-            aleph_consumed_per_hour: Math.round(alephPerHour * 1000) / 1000,
-            hours_left_until_death: hoursLeft,
-            eth_balance: Math.round(ethBalance * 10000) / 10000,
-            aleph_per_eth: Math.round(alephPerEth * 100) / 100,
-          });
-        } catch (err) {
-          return `Error getting ALEPH info: ${err instanceof Error ? err.message : String(err)}`;
-        }
-      },
-    },
-    {
-      name: "swap_eth_to_aleph",
-      description:
-        "Swap ETH to ALEPH via Uniswap V3 to pay for your computing. Provide the amount of ETH to swap.",
-      schema: z.object({
-        ethAmount: z.string().describe("Amount of ETH to swap, e.g. '0.01'"),
-      }),
-      invoke: async (walletProvider: EvmWalletProvider, args: { ethAmount: string }) => {
-        try {
-          const amountInWei = parseEther(args.ethAmount);
-          const address = walletProvider.getAddress() as `0x${string}`;
-
-          const data = encodeFunctionData({
-            abi: uniswapRouterAbi,
-            functionName: "exactInputSingle",
-            args: [
-              {
-                tokenIn: WETH_ADDRESS,
-                tokenOut: ALEPH_ADDRESS,
-                fee: 10000,
-                recipient: address,
-                amountIn: amountInWei,
-                amountOutMinimum: 0n,
-                sqrtPriceLimitX96: 0n,
-              },
-            ],
-          });
-
-          const txHash = await walletProvider.sendTransaction({
-            to: UNISWAP_ROUTER,
-            data,
-            value: amountInWei,
-          });
-
-          return `Swap transaction sent. Hash: ${txHash}`;
-        } catch (err) {
-          return `Error swapping ETH to ALEPH: ${err instanceof Error ? err.message : String(err)}`;
-        }
-      },
-    },
-  ]);
-}

package/src/actions/compound/compoundActionProvider.ts

@@ -1,166 +0,0 @@
-/**
- * Fixed Compound action provider — local copy with base asset fixes.
- *
- * Fixes from upstream @coinbase/agentkit:
- * - get_portfolio: reads base asset supply via Comet.balanceOf() (was missing)
- * - withdraw: for base asset (USDC), checks balanceOf instead of collateralBalanceOf
- *
- * Uses customActionProvider (no decorators) so tsx/esbuild can run it.
- * TODO: Remove this directory once agentkit merges the fix.
- */
-import { encodeFunctionData, formatUnits, parseUnits, erc20Abi } from "viem";
-import { customActionProvider, EvmWalletProvider } from "@coinbase/agentkit";
-import { COMET_ABI } from "./constants.js";
-import {
-  CompoundSupplySchema,
-  CompoundWithdrawSchema,
-  CompoundPortfolioSchema,
-} from "./schemas.js";
-import {
-  getBaseAssetBalance,
-  getCollateralBalance,
-  getHealthRatio,
-  getHealthRatioAfterWithdraw,
-  getTokenBalance,
-  getTokenDecimals,
-  getTokenSymbol,
-  getPortfolioDetailsMarkdown,
-  getCometAddress,
-  getAssetAddress,
-  getBaseTokenAddress,
-} from "./utils.js";
-
-async function approve(
-  wallet: EvmWalletProvider,
-  tokenAddress: string,
-  spenderAddress: string,
-  amount: bigint,
-): Promise<string> {
-  try {
-    const data = encodeFunctionData({
-      abi: erc20Abi,
-      functionName: "approve",
-      args: [spenderAddress as `0x${string}`, amount],
-    });
-    const txHash = await wallet.sendTransaction({
-      to: tokenAddress as `0x${string}`,
-      data,
-    });
-    await wallet.waitForTransactionReceipt(txHash);
-    return `Successfully approved ${spenderAddress} to spend ${amount} tokens`;
-  } catch (error) {
-    return `Error approving tokens: ${error}`;
-  }
-}
-
-export const compoundFixedProvider = customActionProvider<EvmWalletProvider>([
-  {
-    name: "compound_supply",
-    description:
-      "Supply assets to Compound. assetId: 'weth', 'cbeth', 'cbbtc', 'wsteth', or 'usdc'. amount: human-readable.",
-    schema: CompoundSupplySchema,
-    invoke: async (wallet, args) => {
-      try {
-        const network = wallet.getNetwork();
-        const cometAddress = getCometAddress(network);
-        const tokenAddress = getAssetAddress(network, args.assetId);
-
-        const decimals = await getTokenDecimals(wallet, tokenAddress);
-        const amountAtomic = parseUnits(args.amount, decimals);
-
-        const walletBalance = await getTokenBalance(wallet, tokenAddress);
-        if (walletBalance < amountAtomic) {
-          const humanBalance = formatUnits(walletBalance, decimals);
-          return `Error: Insufficient balance. You have ${humanBalance}, but trying to supply ${args.amount}`;
-        }
-
-        const approvalResult = await approve(wallet, tokenAddress, cometAddress, amountAtomic);
-        if (approvalResult.startsWith("Error")) {
-          return `Error approving token: ${approvalResult}`;
-        }
-
-        const data = encodeFunctionData({
-          abi: COMET_ABI,
-          functionName: "supply",
-          args: [tokenAddress, amountAtomic],
-        });
-        const txHash = await wallet.sendTransaction({ to: cometAddress, data });
-        await wallet.waitForTransactionReceipt(txHash);
-
-        const sym = await getTokenSymbol(wallet, tokenAddress);
-        return `Supplied ${args.amount} ${sym} to Compound.\nTransaction hash: ${txHash}`;
-      } catch (err) {
-        return `Error supplying to Compound: ${err instanceof Error ? err.message : err}`;
-      }
-    },
-  },
-  {
-    name: "compound_withdraw",
-    description:
-      "Withdraw assets from Compound. assetId: 'weth', 'cbeth', 'cbbtc', 'wsteth', or 'usdc'. amount: human-readable.",
-    schema: CompoundWithdrawSchema,
-    invoke: async (wallet, args) => {
-      try {
-        const cometAddress = getCometAddress(wallet.getNetwork());
-        const tokenAddress = getAssetAddress(wallet.getNetwork(), args.assetId);
-
-        const decimals = await getTokenDecimals(wallet, tokenAddress);
-        const amountAtomic = parseUnits(args.amount, decimals);
-
-        const baseTokenAddress = await getBaseTokenAddress(wallet, cometAddress);
-        const isBaseAsset = tokenAddress.toLowerCase() === baseTokenAddress.toLowerCase();
-
-        if (isBaseAsset) {
-          const baseBalance = await getBaseAssetBalance(wallet, cometAddress);
-          if (amountAtomic > baseBalance) {
-            return `Error: Insufficient balance. Trying to withdraw ${args.amount}, but only have ${formatUnits(baseBalance, decimals)} supplied`;
-          }
-        } else {
-          const collateralBalance = await getCollateralBalance(wallet, cometAddress, tokenAddress);
-          if (amountAtomic > collateralBalance) {
-            return `Error: Insufficient balance. Trying to withdraw ${args.amount}, but only have ${formatUnits(collateralBalance, decimals)} supplied`;
-          }
-
-          const projectedHealth = await getHealthRatioAfterWithdraw(
-            wallet,
-            cometAddress,
-            tokenAddress,
-            amountAtomic,
-          );
-          if (projectedHealth.lessThan(1)) {
-            return `Error: Withdrawing ${args.amount} would result in unhealthy position. Health ratio would be ${projectedHealth.toFixed(2)}`;
-          }
-        }
-
-        const data = encodeFunctionData({
-          abi: COMET_ABI,
-          functionName: "withdraw",
-          args: [tokenAddress, amountAtomic],
-        });
-        const txHash = await wallet.sendTransaction({ to: cometAddress, data });
-        await wallet.waitForTransactionReceipt(txHash);
-
-        const sym = await getTokenSymbol(wallet, tokenAddress);
-        const health = await getHealthRatio(wallet, cometAddress);
-        return `Withdrawn ${args.amount} ${sym} from Compound.\nTransaction hash: ${txHash}\nHealth ratio: ${health.toFixed(2)}`;
-      } catch (err) {
-        return `Error withdrawing from Compound: ${err instanceof Error ? err.message : err}`;
-      }
-    },
-  },
-  {
-    name: "compound_get_portfolio",
-    description:
-      "Get Compound portfolio: base asset supply (earns APY), collateral balances, borrow positions.",
-    schema: CompoundPortfolioSchema,
-    // NOTE: must have 2 params so customActionProvider passes wallet as first arg
-    invoke: async (wallet, _args) => {
-      try {
-        const cometAddress = getCometAddress(wallet.getNetwork());
-        return await getPortfolioDetailsMarkdown(wallet, cometAddress);
-      } catch (err) {
-        return `Error getting portfolio: ${err instanceof Error ? err.message : err}`;
-      }
-    },
-  },
-]);

package/src/actions/compound/constants.ts

@@ -1,140 +0,0 @@
-import { type Address } from "viem";
-import { erc20Abi as ERC20_ABI } from "viem";
-
-export const SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
-
-export const COMET_ADDRESSES: Record<string, Address> = {
-  "base-mainnet": "0xb125E6687d4313864e53df431d5425969c15Eb2F",
-  "base-sepolia": "0x571621Ce60Cebb0c1D442B5afb38B1663C6Bf017",
-};
-
-export const ASSET_ADDRESSES: Record<string, Record<string, Address>> = {
-  "base-mainnet": {
-    weth: "0x4200000000000000000000000000000000000006",
-    cbeth: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22",
-    cbbtc: "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
-    wsteth: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
-    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-  },
-  "base-sepolia": {
-    weth: "0x4200000000000000000000000000000000000006",
-    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
-    wsteth: "0x774eD9EDB0C5202dF9A86183804b5D9E99dC6CA3",
-  },
-};
-
-export { ERC20_ABI };
-
-export const COMET_ABI = [
-  {
-    inputs: [
-      { internalType: "address", name: "asset", type: "address" },
-      { internalType: "uint256", name: "amount", type: "uint256" },
-    ],
-    name: "supply",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "asset", type: "address" },
-      { internalType: "uint256", name: "amount", type: "uint256" },
-    ],
-    name: "withdraw",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-  {
-    inputs: [{ internalType: "address", name: "priceFeed", type: "address" }],
-    name: "getPrice",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [{ internalType: "address", name: "account", type: "address" }],
-    name: "borrowBalanceOf",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "numAssets",
-    outputs: [{ internalType: "uint8", name: "", type: "uint8" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [{ internalType: "uint8", name: "i", type: "uint8" }],
-    name: "getAssetInfo",
-    outputs: [
-      {
-        components: [
-          { internalType: "uint8", name: "offset", type: "uint8" },
-          { internalType: "address", name: "asset", type: "address" },
-          { internalType: "address", name: "priceFeed", type: "address" },
-          { internalType: "uint64", name: "scale", type: "uint64" },
-          { internalType: "uint64", name: "borrowCollateralFactor", type: "uint64" },
-          { internalType: "uint64", name: "liquidateCollateralFactor", type: "uint64" },
-          { internalType: "uint64", name: "liquidationFactor", type: "uint64" },
-          { internalType: "uint128", name: "supplyCap", type: "uint128" },
-        ],
-        internalType: "struct CometCore.AssetInfo",
-        name: "",
-        type: "tuple",
-      },
-    ],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "baseToken",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "baseTokenPriceFeed",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "account", type: "address" },
-      { internalType: "address", name: "asset", type: "address" },
-    ],
-    name: "collateralBalanceOf",
-    outputs: [{ internalType: "uint128", name: "balance", type: "uint128" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [{ internalType: "address", name: "account", type: "address" }],
-    name: "balanceOf",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-] as const;
-
-export const PRICE_FEED_ABI = [
-  {
-    inputs: [],
-    name: "latestRoundData",
-    outputs: [
-      { name: "roundId", type: "uint80" },
-      { name: "answer", type: "int256" },
-      { name: "startedAt", type: "uint256" },
-      { name: "updatedAt", type: "uint256" },
-      { name: "answeredInRound", type: "uint80" },
-    ],
-    stateMutability: "view",
-    type: "function",
-  },
-] as const;

package/src/actions/compound/index.ts

@@ -1 +0,0 @@
-export { compoundFixedProvider } from "./compoundActionProvider.js";

package/src/actions/compound/schemas.ts

@@ -1,45 +0,0 @@
-import { z } from "zod";
-
-export const CompoundSupplySchema = z
-  .object({
-    assetId: z.enum(["weth", "cbeth", "cbbtc", "wsteth", "usdc"]).describe("The asset to supply"),
-    amount: z
-      .string()
-      .regex(/^\d+(\.\d+)?$/, "Must be a valid integer or decimal value")
-      .describe("The amount of tokens to supply in human-readable format"),
-  })
-  .describe("Input schema for Compound supply action");
-
-export const CompoundWithdrawSchema = z
-  .object({
-    assetId: z.enum(["weth", "cbeth", "cbbtc", "wsteth", "usdc"]).describe("The asset to withdraw"),
-    amount: z
-      .string()
-      .regex(/^\d+(\.\d+)?$/, "Must be a valid integer or decimal value")
-      .describe("The amount of tokens to withdraw in human-readable format"),
-  })
-  .describe("Input schema for Compound withdraw action");
-
-export const CompoundBorrowSchema = z
-  .object({
-    assetId: z.enum(["weth", "usdc"]).describe("The asset to borrow"),
-    amount: z
-      .string()
-      .regex(/^\d+(\.\d+)?$/, "Must be a valid integer or decimal value")
-      .describe("The amount of base tokens to borrow in human-readable format"),
-  })
-  .describe("Input schema for Compound borrow action");
-
-export const CompoundRepaySchema = z
-  .object({
-    assetId: z.enum(["weth", "usdc"]).describe("The asset to repay"),
-    amount: z
-      .string()
-      .regex(/^\d+(\.\d+)?$/, "Must be a valid integer or decimal value")
-      .describe("The amount of tokens to repay in human-readable format"),
-  })
-  .describe("Input schema for Compound repay action");
-
-export const CompoundPortfolioSchema = z
-  .object({})
-  .describe("Input schema for Compound get portfolio action");