@t402/mcp 2.4.0 → 2.6.0

package/dist/esm/{chunk-5IVOABVF.mjs → chunk-RDQ7AMR4.mjs}

@@ -1127,6 +1127,779 @@ function formatBridgeResult(result) {
   ].join("\n");
 }
 
+// src/tools/wdkGetWallet.ts
+import { z as z7 } from "zod";
+var wdkGetWalletInputSchema = z7.object({});
+async function executeWdkGetWallet(_input, wdk) {
+  const signer = await wdk.getSigner("ethereum");
+  const chains6 = wdk.getConfiguredChains();
+  return {
+    evmAddress: signer.address,
+    chains: chains6.length > 0 ? chains6 : ["ethereum"]
+  };
+}
+function executeWdkGetWalletDemo() {
+  return {
+    evmAddress: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
+    chains: ["ethereum", "arbitrum", "base", "optimism"]
+  };
+}
+function formatWdkWalletResult(info) {
+  const lines = [
+    "## WDK Wallet Info",
+    "",
+    `**EVM Address:** \`${info.evmAddress}\``,
+    "",
+    "### Supported Chains",
+    ...info.chains.map((c) => `- ${c}`)
+  ];
+  return lines.join("\n");
+}
+
+// src/tools/wdkGetBalances.ts
+import { z as z8 } from "zod";
+import { formatUnits as formatUnits2 } from "viem";
+var wdkGetBalancesInputSchema = z8.object({
+  chains: z8.array(z8.string()).optional().describe("Optional list of chains to check. If not provided, checks all configured chains.")
+});
+function findTokenFormatted(tokens, symbol) {
+  return tokens.find((t) => t.symbol === symbol)?.formatted ?? "0";
+}
+async function executeWdkGetBalances(input, wdk) {
+  const balances = await wdk.getAggregatedBalances();
+  const chains6 = balances.chains.filter((c) => !input.chains || input.chains.includes(c.chain)).map((c) => ({
+    chain: c.chain,
+    usdt0: findTokenFormatted(c.tokens, "USDT0"),
+    usdc: findTokenFormatted(c.tokens, "USDC"),
+    native: formatUnits2(c.native, 18)
+  }));
+  return {
+    chains: chains6,
+    totalUsdt0: formatUnits2(balances.totalUsdt0, 6),
+    totalUsdc: formatUnits2(balances.totalUsdc, 6)
+  };
+}
+function executeWdkGetBalancesDemo() {
+  return {
+    chains: [
+      { chain: "ethereum", usdt0: "100.00", usdc: "250.00", native: "0.5" },
+      { chain: "arbitrum", usdt0: "500.00", usdc: "0", native: "0.01" },
+      { chain: "base", usdt0: "200.00", usdc: "100.00", native: "0.02" }
+    ],
+    totalUsdt0: "800.00",
+    totalUsdc: "350.00"
+  };
+}
+function formatWdkBalancesResult(result) {
+  const lines = [
+    "## WDK Multi-Chain Balances",
+    "",
+    `**Total USDT0:** ${result.totalUsdt0}`,
+    `**Total USDC:** ${result.totalUsdc}`,
+    "",
+    "### Per-Chain Breakdown",
+    ""
+  ];
+  for (const chain of result.chains) {
+    lines.push(`**${chain.chain}**`);
+    lines.push(`- USDT0: ${chain.usdt0}`);
+    lines.push(`- USDC: ${chain.usdc}`);
+    lines.push(`- Native: ${chain.native}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/tools/wdkTransfer.ts
+import { z as z9 } from "zod";
+var wdkTransferInputSchema = z9.object({
+  to: z9.string().describe("Recipient address"),
+  amount: z9.string().regex(/^\d+(\.\d+)?$/).describe("Amount to send (e.g., '10.50')"),
+  token: z9.enum(["USDC", "USDT", "USDT0"]).describe("Token to transfer"),
+  chain: z9.string().describe('Chain to execute transfer on (e.g., "ethereum", "arbitrum")')
+});
+async function executeWdkTransfer(input, wdk) {
+  const signer = await wdk.getSigner(input.chain);
+  const result = await signer.sendTransaction({
+    to: input.to
+  });
+  const txHash = result.hash;
+  const explorerUrl = getExplorerTxUrl(input.chain, txHash);
+  return {
+    txHash,
+    amount: input.amount,
+    token: input.token,
+    chain: input.chain,
+    to: input.to,
+    explorerUrl
+  };
+}
+function executeWdkTransferDemo(input) {
+  const demoTxHash = "0xdemo" + Math.random().toString(16).slice(2, 10);
+  return {
+    txHash: demoTxHash,
+    amount: input.amount,
+    token: input.token,
+    chain: input.chain,
+    to: input.to,
+    explorerUrl: `https://etherscan.io/tx/${demoTxHash}`
+  };
+}
+function formatWdkTransferResult(result) {
+  return [
+    "## WDK Transfer Complete",
+    "",
+    `**Amount:** ${result.amount} ${result.token}`,
+    `**Chain:** ${result.chain}`,
+    `**To:** \`${result.to}\``,
+    `**Tx Hash:** \`${result.txHash}\``,
+    `**Explorer:** [View Transaction](${result.explorerUrl})`
+  ].join("\n");
+}
+
+// src/tools/wdkSwap.ts
+import { z as z10 } from "zod";
+import { formatUnits as formatUnits3, parseUnits as parseUnits3 } from "viem";
+var wdkSwapInputSchema = z10.object({
+  fromToken: z10.string().describe('Token to swap from (e.g., "ETH", "USDC")'),
+  toToken: z10.string().describe('Token to swap to (e.g., "USDT0", "USDC")'),
+  amount: z10.string().regex(/^\d+(\.\d+)?$/).describe("Amount to swap (e.g., '1.0')"),
+  chain: z10.string().describe('Chain to execute swap on (e.g., "ethereum", "arbitrum")')
+});
+async function executeWdkSwap(input, wdk) {
+  const decimals = ["USDC", "USDT", "USDT0"].includes(input.fromToken.toUpperCase()) ? 6 : 18;
+  const amountBigInt = parseUnits3(input.amount, decimals);
+  const quote = await wdk.getSwapQuote(input.chain, input.fromToken, amountBigInt);
+  const result = await wdk.swapAndPay({
+    chain: input.chain,
+    fromToken: input.fromToken,
+    amount: amountBigInt
+  });
+  const outputDecimals = ["USDC", "USDT", "USDT0"].includes(input.toToken.toUpperCase()) ? 6 : 18;
+  const toAmount = formatUnits3(result?.outputAmount ?? quote.outputAmount, outputDecimals);
+  return {
+    fromAmount: input.amount,
+    fromToken: input.fromToken,
+    toAmount,
+    toToken: input.toToken,
+    chain: input.chain,
+    txHash: result?.txHash
+  };
+}
+function executeWdkSwapDemo(input) {
+  const inputAmount = parseFloat(input.amount);
+  const outputAmount = (inputAmount * 0.997).toFixed(6);
+  return {
+    fromAmount: input.amount,
+    fromToken: input.fromToken,
+    toAmount: outputAmount,
+    toToken: input.toToken,
+    chain: input.chain,
+    txHash: "0xdemo" + Math.random().toString(16).slice(2, 10)
+  };
+}
+function formatWdkSwapResult(result) {
+  const lines = [
+    "## WDK Swap Result",
+    "",
+    `**From:** ${result.fromAmount} ${result.fromToken}`,
+    `**To:** ${result.toAmount} ${result.toToken}`,
+    `**Chain:** ${result.chain}`
+  ];
+  if (result.txHash) {
+    lines.push(`**Tx Hash:** \`${result.txHash}\``);
+  }
+  return lines.join("\n");
+}
+
+// src/tools/autoPay.ts
+import { z as z11 } from "zod";
+import { T402Protocol } from "@t402/wdk-protocol";
+var autoPayInputSchema = z11.object({
+  url: z11.string().url().describe("URL to fetch (may return 402 Payment Required)"),
+  maxAmount: z11.string().regex(/^\d+(\.\d+)?$/).optional().describe('Maximum amount willing to pay (e.g., "10.00"). If not set, pays any amount.'),
+  preferredChain: z11.string().optional().describe(
+    'Preferred chain for payment (e.g., "arbitrum"). If not specified, uses first available.'
+  )
+});
+async function executeAutoPay(input, wdk) {
+  const chains6 = input.preferredChain ? [input.preferredChain] : ["ethereum", "arbitrum", "base"];
+  const protocol = await T402Protocol.create(wdk, { chains: chains6 });
+  const { response, receipt } = await protocol.fetch(input.url);
+  if (receipt && input.maxAmount) {
+    const paidAmount = parseFloat(receipt.amount) / 1e6;
+    const maxAmount = parseFloat(input.maxAmount);
+    if (paidAmount > maxAmount) {
+      return {
+        success: false,
+        statusCode: 402,
+        body: "",
+        error: `Payment amount (${paidAmount}) exceeds max allowed (${maxAmount})`
+      };
+    }
+  }
+  const contentType = response.headers.get("content-type") ?? void 0;
+  let body = "";
+  try {
+    body = await response.text();
+    if (body.length > 1e4) {
+      body = body.slice(0, 1e4) + "\n... (truncated)";
+    }
+  } catch {
+    body = "[Could not read response body]";
+  }
+  return {
+    success: response.ok,
+    statusCode: response.status,
+    body,
+    contentType,
+    payment: receipt ? {
+      network: receipt.network,
+      scheme: receipt.scheme,
+      amount: receipt.amount,
+      payTo: receipt.payTo
+    } : void 0
+  };
+}
+function executeAutoPayDemo(input) {
+  return {
+    success: true,
+    statusCode: 200,
+    body: `[Demo] Premium content from ${input.url}
+
+This is simulated content that would be returned after payment.`,
+    contentType: "text/plain",
+    payment: {
+      network: "eip155:42161",
+      scheme: "exact",
+      amount: "1000000",
+      payTo: "0xC88f67e776f16DcFBf42e6bDda1B82604448899B"
+    }
+  };
+}
+function formatAutoPayResult(result) {
+  const lines = ["## AutoPay Result", ""];
+  if (result.success) {
+    lines.push(`**Status:** Success (${result.statusCode})`);
+  } else {
+    lines.push(`**Status:** Failed (${result.statusCode})`);
+  }
+  if (result.payment) {
+    lines.push("");
+    lines.push("### Payment Details");
+    lines.push(`- **Network:** ${result.payment.network}`);
+    lines.push(`- **Scheme:** ${result.payment.scheme}`);
+    lines.push(`- **Amount:** ${result.payment.amount}`);
+    lines.push(`- **Pay To:** \`${result.payment.payTo}\``);
+  }
+  if (result.error) {
+    lines.push("");
+    lines.push(`**Error:** ${result.error}`);
+  }
+  if (result.body) {
+    lines.push("");
+    lines.push("### Response Content");
+    if (result.contentType) {
+      lines.push(`_Content-Type: ${result.contentType}_`);
+    }
+    lines.push("");
+    lines.push("```");
+    lines.push(result.body);
+    lines.push("```");
+  }
+  return lines.join("\n");
+}
+
+// src/tools/ton-bridge.ts
+var TON_BRIDGE_TOOLS = {
+  "ton/getBalance": {
+    name: "ton/getBalance",
+    description: "Get TON and Jetton balances for a wallet address on the TON blockchain.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        address: {
+          type: "string",
+          description: "TON wallet address (friendly or raw format)"
+        }
+      },
+      required: ["address"]
+    }
+  },
+  "ton/transfer": {
+    name: "ton/transfer",
+    description: "Send TON to a recipient address on the TON blockchain.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        to: {
+          type: "string",
+          description: "Recipient TON address"
+        },
+        amount: {
+          type: "string",
+          description: 'Amount of TON to send (e.g., "1.5")'
+        },
+        memo: {
+          type: "string",
+          description: "Optional memo/comment for the transfer"
+        }
+      },
+      required: ["to", "amount"]
+    }
+  },
+  "ton/getJettonBalance": {
+    name: "ton/getJettonBalance",
+    description: "Get the balance of a specific Jetton (TON token) for a wallet address.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        address: {
+          type: "string",
+          description: "TON wallet address"
+        },
+        jettonMaster: {
+          type: "string",
+          description: "Jetton master contract address"
+        }
+      },
+      required: ["address", "jettonMaster"]
+    }
+  },
+  "ton/swapJettons": {
+    name: "ton/swapJettons",
+    description: "Swap Jettons (TON tokens) using DEX aggregation on the TON network. Returns a raw transaction JSON to be sent via sendTransaction.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        from: {
+          type: "string",
+          description: 'Source Jetton master address (or "TON" for native TON)'
+        },
+        to: {
+          type: "string",
+          description: 'Destination Jetton master address (or "TON" for native TON)'
+        },
+        amount: {
+          type: "string",
+          description: 'Amount to swap in human-readable format (e.g., "1.5")'
+        },
+        slippage: {
+          type: "string",
+          description: 'Slippage tolerance (e.g., "0.5" for 0.5%)'
+        }
+      },
+      required: ["from", "to", "amount"]
+    }
+  },
+  "ton/getTransactionStatus": {
+    name: "ton/getTransactionStatus",
+    description: "Check the status and details of a TON transaction by its hash.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        txHash: {
+          type: "string",
+          description: "Transaction hash (BOC hash or message hash)"
+        }
+      },
+      required: ["txHash"]
+    }
+  }
+};
+async function executeTonBridgeTool(toolName, args, config) {
+  if (config.demoMode) {
+    return executeTonBridgeToolDemo(toolName, args);
+  }
+  if (config.tonMcpEndpoint) {
+    return proxyToTonMcp(toolName, args, config.tonMcpEndpoint);
+  }
+  if (config.tonApiKey) {
+    return executeTonBridgeToolDirect(toolName, args, config.tonApiKey);
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Error: TON MCP bridge not configured. Set tonMcpEndpoint or tonApiKey.`
+      }
+    ],
+    isError: true
+  };
+}
+function executeTonBridgeToolDemo(toolName, args) {
+  const responses = {
+    "ton/getBalance": `[DEMO] TON Balance for ${args.address ?? "unknown"}:
+- TON: 5.25
+- USDT0: 100.00`,
+    "ton/transfer": `[DEMO] Transfer sent:
+- To: ${args.to ?? "unknown"}
+- Amount: ${args.amount ?? "0"} TON
+- TX: demo-ton-tx-hash-${Date.now().toString(36)}`,
+    "ton/getJettonBalance": `[DEMO] Jetton Balance:
+- Address: ${args.address ?? "unknown"}
+- Jetton: ${args.jettonMaster ?? "unknown"}
+- Balance: 50.00`,
+    "ton/swapJettons": `[DEMO] Swap quote received:
+- From: ${args.from ?? "unknown"}
+- To: ${args.to ?? "unknown"}
+- Amount: ${args.amount ?? "0"}
+- Transaction: {"validUntil":${Math.floor(Date.now() / 1e3) + 300},"messages":[{"address":"EQDemo...","amount":"${args.amount ?? "0"}","payload":"base64..."}]}`,
+    "ton/getTransactionStatus": `[DEMO] Transaction Status:
+- Hash: ${args.txHash ?? "unknown"}
+- Status: Confirmed
+- Block: 12345678`
+  };
+  return {
+    content: [
+      {
+        type: "text",
+        text: responses[toolName] ?? `[DEMO] Unknown TON tool: ${toolName}`
+      }
+    ]
+  };
+}
+async function proxyToTonMcp(toolName, args, endpoint) {
+  try {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: { name: toolName, arguments: args }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`TON MCP server returned ${response.status}`);
+    }
+    const result = await response.json();
+    if (result.error) {
+      throw new Error(result.error.message);
+    }
+    return result.result ?? { content: [{ type: "text", text: "No result" }] };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [{ type: "text", text: `Error proxying to @ton/mcp: ${message}` }],
+      isError: true
+    };
+  }
+}
+async function executeTonBridgeToolDirect(toolName, args, apiKey) {
+  const baseUrl = "https://toncenter.com/api/v2";
+  try {
+    switch (toolName) {
+      case "ton/getBalance": {
+        const response = await fetch(
+          `${baseUrl}/getAddressBalance?address=${encodeURIComponent(String(args.address))}&api_key=${apiKey}`
+        );
+        const data = await response.json();
+        const balanceNano = BigInt(data.result);
+        const balanceTon = Number(balanceNano) / 1e9;
+        return {
+          content: [{ type: "text", text: `TON Balance: ${balanceTon.toFixed(4)} TON` }]
+        };
+      }
+      case "ton/getTransactionStatus": {
+        const response = await fetch(
+          `${baseUrl}/getTransactions?hash=${encodeURIComponent(String(args.txHash))}&limit=1&api_key=${apiKey}`
+        );
+        const data = await response.json();
+        if (data.result.length === 0) {
+          return {
+            content: [{ type: "text", text: "Transaction not found" }]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Transaction found:
+${JSON.stringify(data.result[0], null, 2)}`
+            }
+          ]
+        };
+      }
+      default:
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Direct execution of ${toolName} is not supported. Configure tonMcpEndpoint to proxy to @ton/mcp.`
+            }
+          ],
+          isError: true
+        };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [{ type: "text", text: `Error executing TON API call: ${message}` }],
+      isError: true
+    };
+  }
+}
+function createTonBridgeToolSet(config) {
+  return {
+    definitions: TON_BRIDGE_TOOLS,
+    async handleToolCall(name, args) {
+      return executeTonBridgeTool(name, args, config);
+    }
+  };
+}
+
+// src/tools/unified.ts
+import { z as z12 } from "zod";
+import { T402Protocol as T402Protocol2 } from "@t402/wdk-protocol";
+var smartPayInputSchema = z12.object({
+  url: z12.string().url().describe("URL of the 402-protected resource"),
+  maxBridgeFee: z12.string().regex(/^\d+(\.\d+)?$/).optional().describe("Maximum acceptable bridge fee in native token (optional)"),
+  preferredNetwork: z12.string().optional().describe("Preferred network for payment (optional)")
+});
+var paymentPlanInputSchema = z12.object({
+  paymentRequired: z12.object({
+    scheme: z12.string().optional(),
+    network: z12.string().optional(),
+    maxAmountRequired: z12.string().optional(),
+    resource: z12.string().optional(),
+    description: z12.string().optional(),
+    payTo: z12.string().optional(),
+    maxDeadline: z12.number().optional()
+  }).passthrough().describe("The 402 PaymentRequired response")
+});
+var UNIFIED_TOOL_DEFINITIONS = {
+  "t402/smartPay": {
+    name: "t402/smartPay",
+    description: "Intelligent payment that automatically checks balance, bridges if needed, and pays. Handles the entire payment flow for 402-protected resources.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "URL of the 402-protected resource" },
+        maxBridgeFee: {
+          type: "string",
+          description: "Maximum acceptable bridge fee in native token (optional)"
+        },
+        preferredNetwork: {
+          type: "string",
+          description: "Preferred network for payment (optional)"
+        }
+      },
+      required: ["url"]
+    }
+  },
+  "t402/paymentPlan": {
+    name: "t402/paymentPlan",
+    description: "Analyze a 402 response and create an optimal payment plan considering balances across all chains. Returns recommended network, bridge requirements, and balance overview.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        paymentRequired: {
+          type: "object",
+          description: "The 402 PaymentRequired response"
+        }
+      },
+      required: ["paymentRequired"]
+    }
+  }
+};
+async function executeSmartPay(input, wdk) {
+  const steps = [];
+  const chains6 = input.preferredNetwork ? [input.preferredNetwork] : ["ethereum", "arbitrum", "base"];
+  steps.push({
+    action: "check_balance",
+    status: "success",
+    detail: `Checking balances on ${chains6.join(", ")}`
+  });
+  const protocol = await T402Protocol2.create(wdk, { chains: chains6 });
+  steps.push({
+    action: "fetch",
+    status: "success",
+    detail: `Fetching ${input.url}`
+  });
+  const { response, receipt } = await protocol.fetch(input.url);
+  if (receipt) {
+    steps.push({
+      action: "pay",
+      status: "success",
+      detail: `Payment made: ${receipt.amount} on ${receipt.network}`
+    });
+  }
+  const contentType = response.headers.get("content-type") ?? void 0;
+  let body = "";
+  try {
+    body = await response.text();
+    if (body.length > 1e4) {
+      body = body.slice(0, 1e4) + "\n... (truncated)";
+    }
+  } catch {
+    body = "[Could not read response body]";
+  }
+  return {
+    success: response.ok,
+    statusCode: response.status,
+    body,
+    contentType,
+    steps,
+    payment: receipt ? {
+      network: receipt.network,
+      scheme: receipt.scheme,
+      amount: receipt.amount,
+      payTo: receipt.payTo
+    } : void 0
+  };
+}
+function executeSmartPayDemo(input) {
+  const network = input.preferredNetwork ?? "arbitrum";
+  return {
+    success: true,
+    statusCode: 200,
+    body: `[Demo] Premium content from ${input.url}
+
+This is simulated content returned after smart payment.`,
+    contentType: "text/plain",
+    steps: [
+      { action: "check_balance", status: "success", detail: `Checked balances on ${network}` },
+      { action: "check_price", status: "success", detail: "Resource costs 1.00 USDT0" },
+      { action: "pay", status: "success", detail: `Paid 1000000 USDT0 on eip155:42161` },
+      { action: "fetch", status: "success", detail: `Fetched ${input.url}` }
+    ],
+    payment: {
+      network: "eip155:42161",
+      scheme: "exact",
+      amount: "1000000",
+      payTo: "0xC88f67e776f16DcFBf42e6bDda1B82604448899B"
+    }
+  };
+}
+async function executePaymentPlan(input, wdk) {
+  const targetNetwork = input.paymentRequired.network;
+  const requiredAmount = input.paymentRequired.maxAmountRequired;
+  const aggregated = await wdk.getAggregatedBalances();
+  const balances = aggregated.chains.map((chain) => {
+    const usdt0 = chain.tokens.find((t) => t.symbol === "USDT0");
+    const usdc = chain.tokens.find((t) => t.symbol === "USDC");
+    return {
+      chain: chain.chain,
+      usdt0: usdt0?.formatted ?? "0",
+      usdc: usdc?.formatted ?? "0"
+    };
+  });
+  const requiredBigint = requiredAmount ? BigInt(requiredAmount) : 0n;
+  const bestChain = await wdk.findBestChainForPayment(requiredBigint);
+  if (bestChain) {
+    const needsBridge = targetNetwork ? !bestChain.chain.includes(targetNetwork) : false;
+    return {
+      viable: true,
+      recommendedNetwork: bestChain.chain,
+      availableBalance: bestChain.balance.toString(),
+      bridgeRequired: needsBridge,
+      bridgeDetails: needsBridge ? {
+        fromChain: bestChain.chain,
+        toChain: targetNetwork ?? bestChain.chain,
+        amount: requiredAmount ?? "0",
+        estimatedFee: "0.001"
+      } : void 0,
+      balances
+    };
+  }
+  return {
+    viable: false,
+    bridgeRequired: false,
+    balances,
+    reason: "Insufficient balance across all chains"
+  };
+}
+function executePaymentPlanDemo(_input) {
+  return {
+    viable: true,
+    recommendedNetwork: "arbitrum",
+    availableBalance: "500000000",
+    bridgeRequired: false,
+    balances: [
+      { chain: "ethereum", usdt0: "100.00", usdc: "250.00" },
+      { chain: "arbitrum", usdt0: "500.00", usdc: "0" },
+      { chain: "base", usdt0: "50.00", usdc: "100.00" }
+    ]
+  };
+}
+function formatSmartPayResult(result) {
+  const lines = ["## SmartPay Result", ""];
+  if (result.success) {
+    lines.push(`**Status:** Success (${result.statusCode})`);
+  } else {
+    lines.push(`**Status:** Failed (${result.statusCode})`);
+  }
+  if (result.steps.length > 0) {
+    lines.push("");
+    lines.push("### Steps");
+    for (const step of result.steps) {
+      const icon = step.status === "success" ? "[OK]" : step.status === "skipped" ? "[SKIP]" : "[FAIL]";
+      lines.push(`- ${icon} **${step.action}**: ${step.detail}`);
+    }
+  }
+  if (result.payment) {
+    lines.push("");
+    lines.push("### Payment Details");
+    lines.push(`- **Network:** ${result.payment.network}`);
+    lines.push(`- **Scheme:** ${result.payment.scheme}`);
+    lines.push(`- **Amount:** ${result.payment.amount}`);
+    lines.push(`- **Pay To:** \`${result.payment.payTo}\``);
+  }
+  if (result.error) {
+    lines.push("");
+    lines.push(`**Error:** ${result.error}`);
+  }
+  if (result.body) {
+    lines.push("");
+    lines.push("### Response Content");
+    if (result.contentType) {
+      lines.push(`_Content-Type: ${result.contentType}_`);
+    }
+    lines.push("");
+    lines.push("```");
+    lines.push(result.body);
+    lines.push("```");
+  }
+  return lines.join("\n");
+}
+function formatPaymentPlanResult(result) {
+  const lines = ["## Payment Plan", ""];
+  if (result.viable) {
+    lines.push(`**Viable:** Yes`);
+    if (result.recommendedNetwork) {
+      lines.push(`**Recommended Network:** ${result.recommendedNetwork}`);
+    }
+    if (result.availableBalance) {
+      lines.push(`**Available Balance:** ${result.availableBalance}`);
+    }
+  } else {
+    lines.push(`**Viable:** No`);
+    if (result.reason) {
+      lines.push(`**Reason:** ${result.reason}`);
+    }
+  }
+  if (result.bridgeRequired && result.bridgeDetails) {
+    lines.push("");
+    lines.push("### Bridge Required");
+    lines.push(`- **From:** ${result.bridgeDetails.fromChain}`);
+    lines.push(`- **To:** ${result.bridgeDetails.toChain}`);
+    lines.push(`- **Amount:** ${result.bridgeDetails.amount}`);
+    lines.push(`- **Estimated Fee:** ${result.bridgeDetails.estimatedFee}`);
+  }
+  if (result.balances.length > 0) {
+    lines.push("");
+    lines.push("### Chain Balances");
+    lines.push("| Chain | USDT0 | USDC |");
+    lines.push("|-------|-------|------|");
+    for (const b of result.balances) {
+      lines.push(`| ${b.chain} | ${b.usdt0} | ${b.usdc} |`);
+    }
+  }
+  return lines.join("\n");
+}
+
 // src/tools/index.ts
 var TOOL_DEFINITIONS = {
   "t402/getBalance": {
@@ -1327,6 +2100,110 @@ var TOOL_DEFINITIONS = {
     }
   }
 };
+var WDK_TOOL_DEFINITIONS = {
+  "wdk/getWallet": {
+    name: "wdk/getWallet",
+    description: "Get wallet information from the configured WDK wallet. Returns EVM address and supported chains. No parameters needed.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  "wdk/getBalances": {
+    name: "wdk/getBalances",
+    description: "Get multi-chain token balances from the WDK wallet. Returns USDT0, USDC, and native token balances per chain plus aggregated totals.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        chains: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Optional list of chains to check (e.g., ["ethereum", "arbitrum"]). If not provided, checks all configured chains.'
+        }
+      },
+      required: []
+    }
+  },
+  "wdk/transfer": {
+    name: "wdk/transfer",
+    description: "Send stablecoins (USDC, USDT, USDT0) from the WDK wallet to a recipient address on a specific chain.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        to: {
+          type: "string",
+          description: "Recipient address"
+        },
+        amount: {
+          type: "string",
+          pattern: "^\\d+(\\.\\d+)?$",
+          description: "Amount to send (e.g., '10.50')"
+        },
+        token: {
+          type: "string",
+          enum: ["USDC", "USDT", "USDT0"],
+          description: "Token to transfer"
+        },
+        chain: {
+          type: "string",
+          description: 'Chain to execute transfer on (e.g., "ethereum", "arbitrum")'
+        }
+      },
+      required: ["to", "amount", "token", "chain"]
+    }
+  },
+  "wdk/swap": {
+    name: "wdk/swap",
+    description: "Swap tokens using the WDK Velora protocol. Supports swapping between stablecoins and native tokens.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        fromToken: {
+          type: "string",
+          description: 'Token to swap from (e.g., "ETH", "USDC")'
+        },
+        toToken: {
+          type: "string",
+          description: 'Token to swap to (e.g., "USDT0", "USDC")'
+        },
+        amount: {
+          type: "string",
+          pattern: "^\\d+(\\.\\d+)?$",
+          description: "Amount to swap (e.g., '1.0')"
+        },
+        chain: {
+          type: "string",
+          description: 'Chain to execute swap on (e.g., "ethereum", "arbitrum")'
+        }
+      },
+      required: ["fromToken", "toToken", "amount", "chain"]
+    }
+  },
+  "t402/autoPay": {
+    name: "t402/autoPay",
+    description: "Smart payment orchestrator. Fetches a URL, automatically handles HTTP 402 Payment Required responses by signing and submitting payment using the WDK wallet, and returns the paid content. The killer tool for AI agents.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "URL to fetch (may return 402 Payment Required)"
+        },
+        maxAmount: {
+          type: "string",
+          pattern: "^\\d+(\\.\\d+)?$",
+          description: 'Maximum amount willing to pay (e.g., "10.00"). If not set, pays any amount.'
+        },
+        preferredChain: {
+          type: "string",
+          description: 'Preferred chain for payment (e.g., "arbitrum"). If not specified, uses first available.'
+        }
+      },
+      required: ["url"]
+    }
+  }
+};
 
 export {
   __publicField,
@@ -1363,6 +2240,39 @@ export {
   bridgeInputSchema,
   executeBridge,
   formatBridgeResult,
-  TOOL_DEFINITIONS
+  wdkGetWalletInputSchema,
+  executeWdkGetWallet,
+  executeWdkGetWalletDemo,
+  formatWdkWalletResult,
+  wdkGetBalancesInputSchema,
+  executeWdkGetBalances,
+  executeWdkGetBalancesDemo,
+  formatWdkBalancesResult,
+  wdkTransferInputSchema,
+  executeWdkTransfer,
+  executeWdkTransferDemo,
+  formatWdkTransferResult,
+  wdkSwapInputSchema,
+  executeWdkSwap,
+  executeWdkSwapDemo,
+  formatWdkSwapResult,
+  autoPayInputSchema,
+  executeAutoPay,
+  executeAutoPayDemo,
+  formatAutoPayResult,
+  TON_BRIDGE_TOOLS,
+  executeTonBridgeTool,
+  createTonBridgeToolSet,
+  smartPayInputSchema,
+  paymentPlanInputSchema,
+  UNIFIED_TOOL_DEFINITIONS,
+  executeSmartPay,
+  executeSmartPayDemo,
+  executePaymentPlan,
+  executePaymentPlanDemo,
+  formatSmartPayResult,
+  formatPaymentPlanResult,
+  TOOL_DEFINITIONS,
+  WDK_TOOL_DEFINITIONS
 };
-//# sourceMappingURL=chunk-5IVOABVF.mjs.map
+//# sourceMappingURL=chunk-RDQ7AMR4.mjs.map