web3agent 0.1.0 → 0.2.0

package/dist/mcp/index.js

@@ -0,0 +1,276 @@
+import {
+  VERSION,
+  createGoatToolMetadata,
+  createRuntime,
+  createStartupReport,
+  formatHealthSummary,
+  getAcpToolDefinitions,
+  getAgdpToolDefinitions,
+  getErc8004ToolDefinitions,
+  getErc8183ToolDefinitions,
+  getEvmToolDefinitions,
+  getLifiToolDefinitions,
+  getOrbsToolDefinitions,
+  getTokenToolDefinitions,
+  getTransactionToolDefinitions,
+  getUtilityToolDefinitions,
+  getWalletToolDefinitions,
+  getX402ToolDefinitions,
+  normalizeInputSchema,
+  toHealthStatus
+} from "../chunk-B4LSSN7C.js";
+import "../chunk-ETI3ZR2C.js";
+import "../chunk-4G55KHRO.js";
+import {
+  dispatchGoatTool,
+  formatToolError
+} from "../chunk-BJUU5ESI.js";
+import {
+  walletEvents
+} from "../chunk-KPRIUALX.js";
+import "../chunk-7QEKU2RP.js";
+
+// src/runtime/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+function toMcpTool(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: normalizeInputSchema(tool.inputSchema),
+    ...tool.annotations && { annotations: tool.annotations }
+  };
+}
+function getGoatTools(goatProvider) {
+  const snapshot = goatProvider.getReferenceSnapshot();
+  if (!snapshot) return [];
+  return snapshot.listOfTools.map((tool) => createGoatToolMetadata(tool));
+}
+function createLegacyRuntimeBridge(blockscoutAdapter, etherscanAdapter, goatProvider) {
+  const frameworkTools = [
+    ...getWalletToolDefinitions(),
+    ...getTransactionToolDefinitions(),
+    ...getUtilityToolDefinitions()
+  ];
+  const lifiTools = getLifiToolDefinitions();
+  const orbsTools = getOrbsToolDefinitions();
+  const tokenTools = getTokenToolDefinitions();
+  const x402Tools = getX402ToolDefinitions();
+  const erc8183Tools = getErc8183ToolDefinitions();
+  const acpVirtualsTools = getAcpToolDefinitions();
+  const agdpTools = getAgdpToolDefinitions();
+  const erc8004Tools = getErc8004ToolDefinitions();
+  const evmNativeTools = getEvmToolDefinitions();
+  let goatToolNames = new Set(goatProvider.getAllToolNames());
+  const toolDispatch = /* @__PURE__ */ new Map();
+  const rebuildDispatchMap = () => {
+    toolDispatch.clear();
+    for (const tool of blockscoutAdapter.getTools()) {
+      toolDispatch.set(
+        tool.name,
+        (args) => blockscoutAdapter.callTool(tool.name, args)
+      );
+    }
+    for (const tool of etherscanAdapter.getTools()) {
+      toolDispatch.set(
+        tool.name,
+        (args) => etherscanAdapter.callTool(tool.name, args)
+      );
+    }
+    for (const tool of evmNativeTools) {
+      toolDispatch.set(tool.name, (args) => tool.handler(args));
+    }
+    for (const tool of tokenTools) {
+      toolDispatch.set(tool.name, (args) => tool.handler(args));
+    }
+    for (const name of goatToolNames) {
+      toolDispatch.set(name, (args) => dispatchGoatTool(name, args));
+    }
+    for (const tool of lifiTools) {
+      toolDispatch.set(tool.name, (args) => tool.handler(args));
+    }
+    for (const tool of orbsTools) {
+      toolDispatch.set(tool.name, (args) => tool.handler(args));
+    }
+    for (const tool of x402Tools) {
+      toolDispatch.set(tool.name, (args) => tool.handler(args));
+    }
+    for (const tool of erc8183Tools) {
+      toolDispatch.set(tool.name, (args) => tool.handler(args));
+    }
+    for (const tool of acpVirtualsTools) {
+      toolDispatch.set(tool.name, (args) => tool.handler(args));
+    }
+    for (const tool of agdpTools) {
+      toolDispatch.set(tool.name, (args) => tool.handler(args));
+    }
+    for (const tool of erc8004Tools) {
+      toolDispatch.set(tool.name, (args) => tool.handler(args));
+    }
+    for (const tool of frameworkTools) {
+      toolDispatch.set(tool.name, (args) => tool.handler(args));
+    }
+  };
+  rebuildDispatchMap();
+  return {
+    getMcpTools() {
+      return [
+        ...frameworkTools.map(toMcpTool),
+        ...getGoatTools(goatProvider),
+        ...blockscoutAdapter.getTools(),
+        ...etherscanAdapter.getTools(),
+        ...evmNativeTools.map(toMcpTool),
+        ...lifiTools.map(toMcpTool),
+        ...orbsTools.map(toMcpTool),
+        ...tokenTools.map(toMcpTool),
+        ...x402Tools.map(toMcpTool),
+        ...erc8183Tools.map(toMcpTool),
+        ...acpVirtualsTools.map(toMcpTool),
+        ...agdpTools.map(toMcpTool),
+        ...erc8004Tools.map(toMcpTool)
+      ];
+    },
+    async invokeTool(name, args = {}) {
+      const handler = toolDispatch.get(name);
+      if (!handler) {
+        return formatToolError("UNKNOWN_TOOL", `Unknown tool: ${name}`);
+      }
+      return handler(args);
+    },
+    onToolsChanged(listener) {
+      const handler = () => {
+        goatProvider.waitForRebuild().then(() => {
+          goatToolNames = new Set(goatProvider.getAllToolNames());
+          rebuildDispatchMap();
+          listener();
+        }).catch((e) => {
+          process.stderr.write(`[web3agent] Failed to update tools after wallet change: ${e}
+`);
+        });
+      };
+      walletEvents.on("wallet-changed", handler);
+      return () => {
+        walletEvents.off("wallet-changed", handler);
+      };
+    },
+    async shutdown() {
+      goatProvider.shutdown();
+      await goatProvider.waitForRebuild().catch(() => {
+      });
+      await Promise.allSettled([blockscoutAdapter.shutdown(), etherscanAdapter.shutdown()]);
+    }
+  };
+}
+function isRuntimeBridge(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.getMcpTools === "function" && typeof candidate.invokeTool === "function" && typeof candidate.onToolsChanged === "function" && typeof candidate.shutdown === "function";
+}
+function requireLegacyAdapter(value, name) {
+  if (value === void 0) {
+    throw new Error(
+      `Legacy ProxyServer construction requires ${name}; use createRuntime() for the managed runtime path`
+    );
+  }
+  return value;
+}
+var ProxyServer = class {
+  server;
+  removeToolsChangedListener;
+  runtime;
+  constructor(runtimeOrBlockscout, etherscanAdapter, goatProviderInstance) {
+    this.runtime = isRuntimeBridge(runtimeOrBlockscout) ? runtimeOrBlockscout : createLegacyRuntimeBridge(
+      runtimeOrBlockscout,
+      requireLegacyAdapter(etherscanAdapter, "etherscanAdapter"),
+      requireLegacyAdapter(goatProviderInstance, "goatProvider")
+    );
+    this.server = new Server(
+      { name: "web3agent", version: VERSION },
+      {
+        capabilities: { tools: { listChanged: true } },
+        instructions: [
+          "web3agent is a unified Web3 MCP proxy server.",
+          "Token resolution: ALWAYS call resolve_token before swaps/bridges to get the correct contract address.",
+          "Write operations: By default, writes (swaps, bridges, transfers) are queued. Call transaction_confirm(id) to execute, transaction_deny(id) to discard.",
+          "Wallet activation: Call wallet_activate with a private key or mnemonic to enable write operations. Call wallet_get_active to check current state.",
+          "Browser wallet flows: Use the *_prepare_* intent tools plus transaction_simulate to prepare and inspect externally signed transactions. Generic MCP hosts cannot trigger browser wallet signing prompts themselves.",
+          "Chain selection: Most tools accept an optional chainId parameter. Default chain is Base (8453).",
+          "Tool routing: Use blockscout_* for historical/indexed data, evm_* for live on-chain state, other tools for DeFi operations."
+        ].join(" ")
+      }
+    );
+    this.registerHandlers();
+    this.removeToolsChangedListener = this.runtime.onToolsChanged(() => {
+      this.server.notification({ method: "notifications/tools/list_changed" }).catch((e) => {
+        process.stderr.write(`[web3agent] Failed to emit tools/list_changed: ${e}
+`);
+      });
+    });
+  }
+  registerHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: this.getAggregatedTools()
+    }));
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const name = request.params.name;
+      const args = request.params.arguments ?? {};
+      return this.runtime.invokeTool(name, args);
+    });
+  }
+  getAggregatedTools() {
+    return this.runtime.getMcpTools();
+  }
+  async shutdown() {
+    if (this.removeToolsChangedListener) {
+      this.removeToolsChangedListener();
+      this.removeToolsChangedListener = void 0;
+    }
+    await this.runtime.shutdown();
+    await this.server.close().catch((e) => {
+      process.stderr.write(`[web3agent] Failed to close MCP server: ${e}
+`);
+    });
+  }
+  async connect(transport) {
+    await this.server.connect(transport);
+  }
+  async start() {
+    const transport = new StdioServerTransport();
+    await this.connect(transport);
+  }
+};
+
+// src/runtime/startup.ts
+async function startServer() {
+  const runtime = await createRuntime();
+  const server = new ProxyServer(runtime);
+  const health = runtime.getHealth();
+  const report = createStartupReport({
+    health: toHealthStatus(health),
+    activeChainId: runtime.config.chainId,
+    walletMode: health.walletMode,
+    walletAddress: health.walletAddress,
+    confirmWrites: health.confirmWrites,
+    degradedServices: Object.entries(health.backends).filter(([, backend]) => backend.status !== "ok" && backend.status !== "not_configured").map(([name]) => name),
+    totalToolCount: health.toolCount,
+    pendingOpsRestored: runtime.pendingOpsRestored > 0 ? runtime.pendingOpsRestored : void 0
+  });
+  process.stderr.write(`${formatHealthSummary(report)}
+`);
+  let shuttingDown = false;
+  const gracefulShutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    process.stderr.write("[web3agent] Shutting down...\n");
+    await server.shutdown();
+    process.exit(0);
+  };
+  process.on("SIGTERM", gracefulShutdown);
+  process.on("SIGINT", gracefulShutdown);
+  await server.start();
+}
+export {
+  ProxyServer,
+  startServer
+};

package/dist/runtime/index.d.ts

@@ -0,0 +1,8 @@
+export { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export { c as createRuntime } from '../managed-runtime-DCLqOBjp.js';
+export { C as CreateRuntimeOptions, R as RuntimeHealth, T as ToolCatalogEntry, d as ToolCategory, e as ToolErrorPayload, f as ToolResultError, g as ToolResultPayload, h as ToolSource, i as ToolSuccessPayload, W as Web3AgentRuntime } from '../types-B_VpZGqQ.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+
+declare function shutdownDefaultRuntime(): Promise<void>;
+
+export { shutdownDefaultRuntime };

package/dist/runtime/index.js

@@ -0,0 +1,15 @@
+import {
+  shutdownDefaultRuntime
+} from "../chunk-7ITJ5WGE.js";
+import {
+  createRuntime
+} from "../chunk-B4LSSN7C.js";
+import "../chunk-ETI3ZR2C.js";
+import "../chunk-4G55KHRO.js";
+import "../chunk-BJUU5ESI.js";
+import "../chunk-KPRIUALX.js";
+import "../chunk-7QEKU2RP.js";
+export {
+  createRuntime,
+  shutdownDefaultRuntime
+};

package/dist/types-B_VpZGqQ.d.ts

@@ -0,0 +1,174 @@
+import { Tool, CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+
+interface RuntimeConfig {
+    chainId: number;
+    privateKey?: string;
+    mnemonic?: string;
+    walletAccountIndex: number;
+    walletAddressIndex: number;
+    rpcUrl?: string;
+    /** Per-chain RPC overrides keyed by chain ID, parsed from RPC_URL_<chainId> env vars. */
+    chainRpcUrls: Record<number, string>;
+    confirmWrites: boolean;
+    confirmTtlMinutes: number;
+    blockscoutMcpUrl: string;
+    etherscanMcpUrl: string;
+    etherscanApiKey?: string;
+    lifiApiKey?: string;
+    zeroxApiKey?: string;
+    coingeckoApiKey?: string;
+    orbsPartner?: string;
+    acpContractAddress?: string;
+    acpPaymentToken?: string;
+    pinataJwt?: string;
+    erc8004AgentUri?: string;
+    agdpApiUrl?: string;
+}
+
+type BackendStatusCode = "ok" | "degraded" | "unavailable" | "not_configured";
+interface BackendStatus {
+    name: string;
+    status: BackendStatusCode;
+    message?: string;
+    toolCount?: number;
+}
+
+type WalletMode = "private-key" | "mnemonic" | "read-only";
+interface WalletState {
+    mode: WalletMode;
+    address?: string;
+    chainId: number;
+    accountIndex: number;
+    addressIndex: number;
+}
+
+type ToolSource = "wallet" | "transaction" | "operation" | "utility" | "tokens" | "lifi" | "orbs" | "goat" | "blockscout" | "etherscan" | "evm" | "x402" | "acp" | "agdp" | "erc8004";
+type ToolCategory = "wallet" | "transaction" | "operation" | "status" | "tokens" | "swap" | "orders" | "onchain" | "explorer" | "agenticEconomy";
+interface ToolCatalogEntry {
+    name: string;
+    description: string;
+    inputSchema: Tool["inputSchema"];
+    source: ToolSource;
+    category: ToolCategory;
+    dynamic: boolean;
+    annotations?: Tool["annotations"];
+}
+interface ToolResultError {
+    code: string;
+    message: string;
+    details?: unknown;
+}
+interface ToolSuccessPayload<T = unknown> {
+    ok: true;
+    data: T;
+}
+interface ToolErrorPayload {
+    ok: false;
+    error: ToolResultError;
+}
+type ToolResultPayload<T = unknown> = ToolSuccessPayload<T> | ToolErrorPayload;
+interface RuntimeHealth {
+    activeChainId: number;
+    walletMode: WalletMode;
+    walletAddress?: string;
+    confirmWrites: boolean;
+    toolCount: number;
+    backends: {
+        blockscout: BackendStatus;
+        etherscan: BackendStatus;
+        evm: BackendStatus;
+        goat: BackendStatus;
+        lifi: BackendStatus;
+        orbs: BackendStatus;
+        agenticEconomy: BackendStatus;
+    };
+}
+type RuntimeToolListener = () => void;
+interface WalletGenerateResult {
+    address: string;
+    privateKey: string;
+    warning: string;
+}
+interface WalletGenerateMnemonicResult {
+    mnemonic: string;
+    firstAddress: string;
+    derivationPath: string;
+    warning: string;
+}
+interface WalletAddressDerivationResult {
+    address: string;
+    derivationPath: string;
+}
+interface WalletDerivedAddressEntry {
+    index: number;
+    address: string;
+    derivationPath: string;
+}
+interface WalletActiveResult {
+    mode: string;
+    chainId: number;
+    address?: string;
+}
+interface WalletDeactivationResult {
+    mode: string;
+    message: string;
+}
+interface WalletConfirmationResult {
+    confirmationRequired: boolean;
+    message: string;
+}
+interface TransactionListEntry {
+    id: string;
+    type: string;
+    description: string;
+    createdAt: string;
+    expiresIn: number;
+    walletAddress?: string;
+}
+interface TransactionListResult {
+    count: number;
+    operations: TransactionListEntry[];
+}
+interface TransactionConfirmResult {
+    confirmed: true;
+    id: string;
+    [key: string]: unknown;
+}
+interface TransactionDenyResult {
+    denied: true;
+    id: string;
+    message: string;
+}
+interface Web3AgentRuntime {
+    readonly config: RuntimeConfig;
+    listTools(): ToolCatalogEntry[];
+    getTool(name: string): ToolCatalogEntry | undefined;
+    invokeTool(name: string, args?: Record<string, unknown>): Promise<CallToolResult>;
+    getHealth(): RuntimeHealth;
+    shutdown(): Promise<void>;
+    wallet: {
+        generate(): Promise<WalletGenerateResult>;
+        generateMnemonic(): Promise<WalletGenerateMnemonicResult>;
+        fromMnemonic(params: Record<string, unknown>): Promise<WalletAddressDerivationResult>;
+        deriveAddresses(params: Record<string, unknown>): Promise<WalletDerivedAddressEntry[]>;
+        getActive(): Promise<WalletActiveResult>;
+        activate(params: Record<string, unknown>): Promise<WalletActiveResult>;
+        deactivate(): Promise<WalletDeactivationResult>;
+        setConfirmation(params: Record<string, unknown>): Promise<WalletConfirmationResult>;
+    };
+    transactions: {
+        list(): Promise<TransactionListResult>;
+        confirm(id: string): Promise<TransactionConfirmResult>;
+        deny(id: string): Promise<TransactionDenyResult>;
+    };
+    status: {
+        server(): Promise<RuntimeHealth>;
+        supportedChains(): Promise<unknown>;
+    };
+}
+interface CreateRuntimeOptions {
+    config?: RuntimeConfig;
+    env?: Partial<Record<string, string>>;
+}
+
+export type { BackendStatus as B, CreateRuntimeOptions as C, RuntimeHealth as R, ToolCatalogEntry as T, Web3AgentRuntime as W, WalletState as a, RuntimeConfig as b, RuntimeToolListener as c, ToolCategory as d, ToolErrorPayload as e, ToolResultError as f, ToolResultPayload as g, ToolSource as h, ToolSuccessPayload as i, BackendStatusCode as j, WalletGenerateResult as k, WalletGenerateMnemonicResult as l, WalletAddressDerivationResult as m, WalletDerivedAddressEntry as n, WalletActiveResult as o, WalletDeactivationResult as p, WalletConfirmationResult as q, TransactionListResult as r, TransactionConfirmResult as s, TransactionDenyResult as t };

package/dist/x402/client.d.ts

@@ -0,0 +1,13 @@
+import { x402Client, PaymentRequired } from '@x402/fetch';
+
+type X402ClientResult = {
+    client: x402Client;
+    fetchWithPayment: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+};
+declare function createX402Client(chainId: number): X402ClientResult;
+declare function probePaymentRequirements(url: string, method?: string, headers?: Record<string, string>, body?: string): Promise<{
+    requirements: PaymentRequired | null;
+    probeResponse: Response;
+}>;
+
+export { type X402ClientResult, createX402Client, probePaymentRequirements };

package/dist/x402/client.js

@@ -0,0 +1,10 @@
+import {
+  createX402Client,
+  probePaymentRequirements
+} from "../chunk-4G55KHRO.js";
+import "../chunk-KPRIUALX.js";
+import "../chunk-7QEKU2RP.js";
+export {
+  createX402Client,
+  probePaymentRequirements
+};

package/examples/root-api-smoke.mjs

@@ -0,0 +1,30 @@
+import { getChain, isSupportedChain, listChainTokens, resolveCanonicalTokenSync } from "web3agent";
+
+const chainId = 8453;
+const chain = getChain(chainId);
+const sampleToken = resolveCanonicalTokenSync({ symbol: "USDC", chainId });
+const tokens = listChainTokens({ chainId });
+
+process.stdout.write(
+  `${JSON.stringify(
+    {
+      chain: chain
+        ? {
+            id: chain.id,
+            name: chain.name,
+          }
+        : null,
+      supported: isSupportedChain(chainId),
+      sampleToken: sampleToken
+        ? {
+            symbol: sampleToken.symbol,
+            address: sampleToken.address,
+            decimals: sampleToken.decimals,
+          }
+        : null,
+      tokenCount: tokens.tokens.length,
+    },
+    null,
+    2
+  )}\n`
+);

package/examples/runtime-smoke.mjs

@@ -0,0 +1,77 @@
+import { createRuntime } from "web3agent/runtime";
+
+const shouldRun = process.argv.includes("--run");
+
+if (!shouldRun) {
+  process.stdout.write(
+    `${JSON.stringify(
+      {
+        createRuntime: typeof createRuntime,
+        mode: "imports-only",
+        hint: "Pass --run to start the live runtime smoke test.",
+      },
+      null,
+      2
+    )}\n`
+  );
+  process.exit(0);
+}
+
+let runtime;
+
+try {
+  runtime = await createRuntime();
+  const health = runtime.getHealth();
+  const toolPreview = runtime
+    .listTools()
+    .slice(0, 10)
+    .map((tool) => ({
+      name: tool.name,
+      source: tool.source,
+      category: tool.category,
+      dynamic: tool.dynamic,
+    }));
+  const supportedChains = await runtime.invokeTool("list_supported_chains");
+  const supportedChainsPayload = supportedChains.structuredContent;
+
+  process.stdout.write(
+    `${JSON.stringify(
+      {
+        mode: "live-runtime",
+        health: {
+          activeChainId: health.activeChainId,
+          walletMode: health.walletMode,
+          toolCount: health.toolCount,
+          backends: Object.fromEntries(
+            Object.entries(health.backends).map(([name, backend]) => [name, backend.status])
+          ),
+        },
+        toolPreview,
+        supportedChains:
+          supportedChainsPayload?.ok === true
+            ? supportedChainsPayload.data
+            : supportedChainsPayload?.ok === false
+              ? supportedChainsPayload.error
+              : supportedChains,
+      },
+      null,
+      2
+    )}\n`
+  );
+} catch (error) {
+  process.stderr.write(
+    `[runtime-smoke] Failed to start live runtime: ${error instanceof Error ? error.message : String(error)}\n`
+  );
+  process.stderr.write(
+    "[runtime-smoke] This path requires live adapter initialization and network access.\n"
+  );
+  process.exitCode = 1;
+} finally {
+  if (runtime) {
+    await runtime.shutdown().catch((error) => {
+      process.stderr.write(
+        `[runtime-smoke] Failed to shut down runtime cleanly: ${error instanceof Error ? error.message : String(error)}\n`
+      );
+    });
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web3agent",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Web3 MCP proxy server — gives AI agents complete blockchain capabilities through a single install",
   "license": "MIT",
   "author": "Apeguru <hello@apeguru.dev>",
@@ -21,15 +21,28 @@
     "cursor"
   ],
   "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "import": "./dist/runtime/index.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp/index.d.ts",
+      "import": "./dist/mcp/index.js"
+    }
+  },
   "bin": {
-    "web3agent": "dist/index.js"
+    "web3agent": "dist/cli.js"
   },
-  "files": ["dist", "WEB3_CONTEXT.md", "README.md", "LICENSE"],
+  "files": ["dist", "examples", "WEB3_CONTEXT.md", "README.md", "LICENSE"],
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
   "dependencies": {
-    "@goat-sdk/adapter-model-context-protocol": "^0.2.11",
     "@goat-sdk/core": "^0.5.0",
     "@goat-sdk/plugin-0x": "^0.1.11",
     "@goat-sdk/plugin-balancer": "^0.1.15",
@@ -44,14 +57,17 @@
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@orbs-network/liquidity-hub-sdk": "^1.0.74",
     "@orbs-network/twap-sdk": "^5.0.0",
-    "reflect-metadata": "^0.2.2",
+    "@orbs-network/twap-ui": "4.0.26-fix.1",
+    "@x402/core": "^2.6.0",
+    "@x402/evm": "^2.6.0",
+    "@x402/fetch": "^2.6.0",
     "viem": "^2.0.0",
     "zod": "^3.25.0",
     "zod-to-json-schema": "^3.23.5"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.0",
-    "@types/node": "^20.0.0",
+    "@types/node": "^22.0.0",
     "tsup": "^8.0.0",
     "typescript": "^5.5.0",
     "vitest": "^2.0.0"
@@ -59,7 +75,6 @@
   "pnpm": {
     "peerDependencyRules": {
       "allowedVersions": {
-        "@goat-sdk/adapter-model-context-protocol>@modelcontextprotocol/sdk": "1.27.1",
         "@goat-sdk/core": "0.5.0",
         "viem": "2.47.0",
         "@goat-sdk/wallet-evm": "0.3.0",
@@ -74,7 +89,7 @@
     "lint": "biome check .",
     "lint:fix": "biome check --write .",
     "typecheck": "tsc --noEmit",
-    "pack:check": "pnpm pack --dry-run"
+    "pack:check": "node -e \"const { execFileSync } = require('node:child_process'); const { mkdtempSync, rmSync } = require('node:fs'); const { tmpdir } = require('node:os'); const { join } = require('node:path'); const dir = mkdtempSync(join(tmpdir(), 'web3agent-pack-')); try { execFileSync(process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm', ['pack', '--pack-destination', dir], { stdio: 'inherit' }); } finally { rmSync(dir, { recursive: true, force: true }); }\""
   },
   "packageManager": "pnpm@9.15.4+sha512.b2dc20e2fc72b3e18848459b37359a32064663e5627a51e4c74b2c29dd8e8e0491483c3abb40789cfd578bf362fb6ba8261b05f0387d76792ed6e23ea3b1b6a0"
 }