@goplausible/algorand-mcp 3.0.7 → 3.1.0

package/README.md

@@ -1,7 +1,6 @@
 # Algorand MCP Server
-
-[![npm downloads](https://img.shields.io/npm/dm/algorand-mcp.svg)](https://www.npmjs.com/package/algorand-mcp)
-[![npm version](https://badge.fury.io/js/algorand-mcp.svg)](https://badge.fury.io/js/algorand-mcp)
+[![npm version](https://img.shields.io/npm/v/@goplausible/algorand-mcp.svg)](https://www.npmjs.com/package/@goplausible/algorand-mcp)
+[![npm downloads](https://img.shields.io/npm/dm/@goplausible/algorand-mcp.svg)](https://www.npmjs.com/package/@goplausible/algorand-mcp)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 A comprehensive [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server that gives AI agents and LLMs full access to the Algorand blockchain. Built by [GoPlausible](https://goplausible.com).
@@ -15,12 +14,14 @@ Algorand is a carbon-negative, pure proof-of-stake Layer 1 blockchain with insta
 ## Features
 
 - Secure wallet management via OS keychain — private keys never exposed to agents or LLMs
+- Wallet accounts nicknames, allowances, and daily limits for safe spending control
 - Account creation, key management, and rekeying
 - Transaction building, signing, and submission (payments, assets, applications, key registration)
 - Atomic transaction groups
 - TEAL compilation and disassembly
 - Full Algod and Indexer API access
 - NFDomains (NFD) name service integration
+- x402 and AP2 toolins for Algorand
 - Tinyman AMM integration (pools, swaps, liquidity)
 - ARC-26 URI and QR code generation
 - Algorand knowledge base with full developer documentation taxonomy
@@ -36,7 +37,7 @@ Algorand is a carbon-negative, pure proof-of-stake Layer 1 blockchain with insta
 ### From npm
 
 ```bash
-npm install -g algorand-mcp
+npm install -g @goplausible/algorand-mcp
 ```
 
 ### From source
@@ -50,12 +51,56 @@ npm run build
 
 ## MCP Configuration
 
-The server runs over stdio. Add it to your MCP client configuration to start using it.
+The server runs over **stdio**. There are three ways to invoke it — pick whichever suits your setup:
+
+| Method | Command | When to use |
+|---|---|---|
+| **npx** (recommended) | `npx @goplausible/algorand-mcp` | No install needed, always latest version |
+| **Global install** | `algorand-mcp` | After `npm install -g @goplausible/algorand-mcp` |
+| **Absolute path** | `node /path/to/dist/index.js` | Built from source or local clone |
+
+**No environment variables are required** for standard use. Network selection, pagination, and node URLs are all handled dynamically per tool call.
+
+---
+
+### OpenClaw
+
+No manual configuration needed — install the [`@goplausible/openclaw-algorand-plugin`](https://www.npmjs.com/package/@goplausible/openclaw-algorand-plugin) npm package and the Algorand MCP server is configured automatically:
+
+```bash
+npm install -g @goplausible/openclaw-algorand-plugin
+```
+
+---
 
 ### Claude Desktop
 
 Edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
 
+**Using npx:**
+```json
+{
+  "mcpServers": {
+    "algorand-mcp": {
+      "command": "npx",
+      "args": ["@goplausible/algorand-mcp"]
+    }
+  }
+}
+```
+
+**Using global install:**
+```json
+{
+  "mcpServers": {
+    "algorand-mcp": {
+      "command": "algorand-mcp"
+    }
+  }
+}
+```
+
+**Using absolute path:**
 ```json
 {
   "mcpServers": {
@@ -67,41 +112,143 @@ Edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) o
 }
 ```
 
+---
+
 ### Claude Code
 
-Create `.mcp.json` in your project root (project scope) or configure in `~/.claude.json` (user scope):
+Create `.mcp.json` in your project root (project scope) or `~/.claude.json` (user scope):
 
 ```json
 {
   "mcpServers": {
     "algorand-mcp": {
       "type": "stdio",
-      "command": "node",
-      "args": ["/absolute/path/to/algorand-mcp/dist/index.js"]
+      "command": "npx",
+      "args": ["@goplausible/algorand-mcp"]
     }
   }
 }
 ```
 
-### Cursor / Windsurf
+Or add interactively:
+```bash
+claude mcp add algorand-mcp -- npx @goplausible/algorand-mcp
+```
 
-These editors use the same JSON format as Claude Desktop. Add the server entry to the MCP settings panel or the corresponding config file for your editor.
+---
 
-### Using global npm install
+### Cursor
 
-If you installed globally via `npm install -g algorand-mcp`, you can use the binary name directly:
+Add via **Settings > MCP Servers**, or edit `.cursor/mcp.json` in your project root:
 
 ```json
 {
   "mcpServers": {
     "algorand-mcp": {
-      "command": "algorand-mcp"
+      "command": "npx",
+      "args": ["@goplausible/algorand-mcp"]
     }
   }
 }
 ```
 
-That's it — **no environment variables are required** for standard use. Network selection, pagination, and node URLs are all handled dynamically.
+---
+
+### Windsurf
+
+Add via **Settings > MCP**, or edit `~/.codeium/windsurf/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "algorand-mcp": {
+      "command": "npx",
+      "args": ["@goplausible/algorand-mcp"]
+    }
+  }
+}
+```
+
+---
+
+### VS Code / GitHub Copilot
+
+Edit `.vscode/mcp.json` in your workspace root, or open **Settings > MCP Servers**:
+
+```json
+{
+  "servers": {
+    "algorand-mcp": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["@goplausible/algorand-mcp"]
+    }
+  }
+}
+```
+
+---
+
+### Cline
+
+Add via the **MCP Servers** panel in the Cline sidebar, or edit `~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json` (macOS):
+
+```json
+{
+  "mcpServers": {
+    "algorand-mcp": {
+      "command": "npx",
+      "args": ["@goplausible/algorand-mcp"],
+      "disabled": false
+    }
+  }
+}
+```
+
+---
+
+### OpenAI Codex CLI
+
+Create `.codex/mcp.json` in your project root or `~/.codex/mcp.json` for global scope:
+
+```json
+{
+  "mcpServers": {
+    "algorand-mcp": {
+      "command": "npx",
+      "args": ["@goplausible/algorand-mcp"]
+    }
+  }
+}
+```
+
+---
+
+### Open Code
+
+Edit `~/.config/opencode/config.json`:
+
+```json
+{
+  "mcp": {
+    "algorand-mcp": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["@goplausible/algorand-mcp"]
+    }
+  }
+}
+```
+
+---
+
+### Any MCP-compatible client
+
+The server speaks the standard MCP stdio protocol. For any client not listed above, configure it with:
+
+- **Command:** `npx` (or `algorand-mcp` if globally installed, or `node /path/to/dist/index.js`)
+- **Args:** `["@goplausible/algorand-mcp"]` (for npx)
+- **Transport:** `stdio`
 
 ## Network Selection
 
@@ -256,7 +403,7 @@ See [Secure Wallet](#secure-wallet) for full architecture details.
 | `encode_obj` | Encode object to msgpack |
 | `decode_obj` | Decode msgpack to object |
 
-### Transaction Tools (16 tools)
+### Transaction Tools (18 tools)
 
 | Tool | Description |
 |---|---|
@@ -276,6 +423,8 @@ See [Secure Wallet](#secure-wallet) for full architecture details.
 | `make_app_call_txn` | Create an application call transaction |
 | `assign_group_id` | Assign group ID for atomic transactions |
 | `sign_transaction` | Sign a transaction with a secret key |
+| `encode_unsigned_transaction` | Encode an unsigned transaction to base64 msgpack bytes |
+| `decode_signed_transaction` | Decode a signed transaction blob back to JSON with signature details |
 
 ### Algod Tools (5 tools)
 

package/dist/tools/apiManager/hayrouter/index.d.ts

@@ -0,0 +1,3 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const haystackTools: Tool[];
+export declare function handleHaystackTools(name: string, args: any): Promise<any>;

package/dist/tools/apiManager/hayrouter/index.js

@@ -0,0 +1,35 @@
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { quoteTools, handleQuoteTools } from './quote.js';
+import { swapTools, handleSwapTools } from './swap.js';
+import { optinTools, handleOptinTools } from './optin.js';
+// Combine all Haystack Router tools
+export const haystackTools = [
+    ...quoteTools,
+    ...swapTools,
+    ...optinTools,
+];
+// Handle all Haystack Router tools
+export async function handleHaystackTools(name, args) {
+    try {
+        const combinedArgs = { name, ...args };
+        // Swap execution (must come before quote due to prefix matching)
+        if (name === 'api_haystack_execute_swap') {
+            return handleSwapTools(combinedArgs);
+        }
+        // Quote tools
+        if (name === 'api_haystack_get_swap_quote') {
+            return handleQuoteTools(combinedArgs);
+        }
+        // Opt-in check
+        if (name === 'api_haystack_needs_optin') {
+            return handleOptinTools(combinedArgs);
+        }
+        throw new McpError(ErrorCode.MethodNotFound, `Unknown Haystack Router tool: ${name}`);
+    }
+    catch (error) {
+        if (error instanceof McpError) {
+            throw error;
+        }
+        throw new McpError(ErrorCode.InternalError, `Failed to handle Haystack Router tool: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/tools/apiManager/hayrouter/optin.d.ts

@@ -0,0 +1,3 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const optinTools: Tool[];
+export declare function handleOptinTools(args: any): Promise<any>;

package/dist/tools/apiManager/hayrouter/optin.js

@@ -0,0 +1,47 @@
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { extractNetwork } from '../../../algorand-client.js';
+import { withCommonParams } from '../../commonParams.js';
+import { getRouterClient } from './routerClient.js';
+export const optinTools = [
+    {
+        name: 'api_haystack_needs_optin',
+        description: 'Check if an Algorand address needs to opt into an asset before swapping. Returns true if opt-in is needed, false otherwise. Always returns false for ALGO (ASA 0). Use before executing a swap to determine if wallet_optin_asset should be called first.',
+        inputSchema: withCommonParams({
+            type: 'object',
+            properties: {
+                address: {
+                    type: 'string',
+                    description: 'Algorand address to check'
+                },
+                assetId: {
+                    type: 'integer',
+                    description: 'Asset ID to check opt-in status for'
+                }
+            },
+            required: ['address', 'assetId']
+        })
+    }
+];
+export async function handleOptinTools(args) {
+    const { name, address, assetId } = args;
+    const network = extractNetwork(args);
+    if (network === 'localnet') {
+        throw new McpError(ErrorCode.InvalidRequest, 'Haystack Router is not available on localnet');
+    }
+    if (name === 'api_haystack_needs_optin') {
+        try {
+            const router = getRouterClient(network);
+            const needsOptIn = await router.needsAssetOptIn(address, assetId);
+            return {
+                address,
+                assetId,
+                needsOptIn,
+                network,
+            };
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to check asset opt-in: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    throw new McpError(ErrorCode.MethodNotFound, `Unknown Haystack opt-in tool: ${name}`);
+}

package/dist/tools/apiManager/hayrouter/quote.d.ts

@@ -0,0 +1,3 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const quoteTools: Tool[];
+export declare function handleQuoteTools(args: any): Promise<any>;

package/dist/tools/apiManager/hayrouter/quote.js

@@ -0,0 +1,101 @@
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { extractNetwork } from '../../../algorand-client.js';
+import { withCommonParams } from '../../commonParams.js';
+import { getRouterClient } from './routerClient.js';
+export const quoteTools = [
+    {
+        name: 'api_haystack_get_swap_quote',
+        description: 'Get an optimized swap quote from Haystack Router — a DEX aggregator that finds the best swap route across multiple Algorand DEXes (Tinyman V2, Pact, Folks) and LST protocols (tALGO, xALGO). Returns the best-price quote with route details, USD values, and price impact. Use this to preview a swap before executing. All amounts are in base units (e.g., 1000000 = 1 ALGO).',
+        inputSchema: withCommonParams({
+            type: 'object',
+            properties: {
+                fromASAID: {
+                    type: 'integer',
+                    description: 'Input asset ID (0 = ALGO, 31566704 = USDC, 312769 = USDt, etc.)'
+                },
+                toASAID: {
+                    type: 'integer',
+                    description: 'Output asset ID (0 = ALGO, 31566704 = USDC, 312769 = USDt, etc.)'
+                },
+                amount: {
+                    type: 'integer',
+                    description: 'Amount in base units (e.g., 1000000 = 1 ALGO with 6 decimals)'
+                },
+                type: {
+                    type: 'string',
+                    enum: ['fixed-input', 'fixed-output'],
+                    description: 'Quote type: fixed-input (specify input amount, default) or fixed-output (specify desired output amount)',
+                    default: 'fixed-input'
+                },
+                address: {
+                    type: 'string',
+                    description: 'User Algorand address (optional, needed for auto opt-in detection)'
+                },
+                maxGroupSize: {
+                    type: 'integer',
+                    description: 'Maximum transactions in atomic group (default: 16)',
+                    default: 16
+                },
+                maxDepth: {
+                    type: 'integer',
+                    description: 'Maximum routing hops (default: 4)',
+                    default: 4
+                }
+            },
+            required: ['fromASAID', 'toASAID', 'amount']
+        })
+    }
+];
+export async function handleQuoteTools(args) {
+    const { name, fromASAID, toASAID, amount, type = 'fixed-input', address, maxGroupSize, maxDepth, } = args;
+    const network = extractNetwork(args);
+    if (network === 'localnet') {
+        throw new McpError(ErrorCode.InvalidRequest, 'Haystack Router is not available on localnet');
+    }
+    const router = getRouterClient(network);
+    if (name === 'api_haystack_get_swap_quote') {
+        try {
+            const quoteParams = {
+                fromASAID,
+                toASAID,
+                amount: BigInt(amount),
+                type,
+            };
+            if (address) {
+                quoteParams.address = address;
+            }
+            if (maxGroupSize !== undefined) {
+                quoteParams.maxGroupSize = maxGroupSize;
+            }
+            if (maxDepth !== undefined) {
+                quoteParams.maxDepth = maxDepth;
+            }
+            const quote = await router.newQuote(quoteParams);
+            // Serialize the quote response for MCP transport (convert BigInt to string)
+            const result = {
+                expectedOutput: quote.quote.toString(),
+                inputAmount: quote.amount.toString(),
+                fromASAID: quote.fromASAID,
+                toASAID: quote.toASAID,
+                type: quote.type,
+                usdIn: quote.usdIn,
+                usdOut: quote.usdOut,
+                userPriceImpact: quote.userPriceImpact,
+                marketPriceImpact: quote.marketPriceImpact,
+                route: quote.route,
+                flattenedRoute: quote.flattenedRoute,
+                requiredAppOptIns: quote.requiredAppOptIns,
+                protocolFees: quote.protocolFees,
+                createdAt: quote.createdAt,
+            };
+            if (quote.address) {
+                result.address = quote.address;
+            }
+            return result;
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to get Haystack swap quote: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    throw new McpError(ErrorCode.MethodNotFound, `Unknown Haystack Router tool: ${name}`);
+}

package/dist/tools/apiManager/hayrouter/routerClient.d.ts

@@ -0,0 +1,2 @@
+import { RouterClient } from '@txnlab/haystack-router';
+export declare function getRouterClient(network: string): RouterClient;

package/dist/tools/apiManager/hayrouter/routerClient.js

@@ -0,0 +1,28 @@
+import { RouterClient } from '@txnlab/haystack-router';
+// Free tier API key (60 requests/min)
+const HAYSTACK_API_KEY = process.env.HAYSTACK_API_KEY || '1b72df7e-1131-4449-8ce1-29b79dd3f51e';
+// Algod URIs per network for RouterClient configuration
+const ALGOD_URIS = {
+    mainnet: 'https://mainnet-api.algonode.cloud',
+    testnet: 'https://testnet-api.algonode.cloud',
+};
+// Memoized RouterClient instances per network
+const routerClients = new Map();
+export function getRouterClient(network) {
+    let client = routerClients.get(network);
+    if (!client) {
+        const config = {
+            apiKey: HAYSTACK_API_KEY,
+            autoOptIn: true,
+        };
+        if (network === 'testnet') {
+            config.algodUri = ALGOD_URIS.testnet;
+        }
+        else if (network === 'mainnet') {
+            config.algodUri = ALGOD_URIS.mainnet;
+        }
+        client = new RouterClient(config);
+        routerClients.set(network, client);
+    }
+    return client;
+}

package/dist/tools/apiManager/hayrouter/swap.d.ts

@@ -0,0 +1,3 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const swapTools: Tool[];
+export declare function handleSwapTools(args: any): Promise<any>;

package/dist/tools/apiManager/hayrouter/swap.js

@@ -0,0 +1,151 @@
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import algosdk from 'algosdk';
+import { extractNetwork } from '../../../algorand-client.js';
+import { WalletManager } from '../../walletManager.js';
+import { withCommonParams } from '../../commonParams.js';
+import { getRouterClient } from './routerClient.js';
+export const swapTools = [
+    {
+        name: 'api_haystack_execute_swap',
+        description: 'Execute an optimized token swap via Haystack Router — gets the best route across multiple DEXes (Tinyman V2, Pact, Folks) and LST protocols, then signs and submits the atomic transaction group using the active wallet account. This is an all-in-one tool: quote → sign → submit → confirm. All amounts are in base units (e.g., 1000000 = 1 ALGO).',
+        inputSchema: withCommonParams({
+            type: 'object',
+            properties: {
+                fromASAID: {
+                    type: 'integer',
+                    description: 'Input asset ID (0 = ALGO, 31566704 = USDC, 312769 = USDt, etc.)'
+                },
+                toASAID: {
+                    type: 'integer',
+                    description: 'Output asset ID (0 = ALGO, 31566704 = USDC, 312769 = USDt, etc.)'
+                },
+                amount: {
+                    type: 'integer',
+                    description: 'Amount in base units (e.g., 1000000 = 1 ALGO with 6 decimals)'
+                },
+                slippage: {
+                    type: 'number',
+                    description: 'Slippage tolerance percentage (e.g., 1 = 1%). Recommended: 0.5-1% stable pairs, 1-3% volatile, 3-5% low liquidity',
+                    default: 1
+                },
+                type: {
+                    type: 'string',
+                    enum: ['fixed-input', 'fixed-output'],
+                    description: 'Quote type: fixed-input (specify input, default) or fixed-output (specify desired output)',
+                    default: 'fixed-input'
+                },
+                note: {
+                    type: 'string',
+                    description: 'Optional note to attach to the input transaction (plain text)'
+                },
+                maxGroupSize: {
+                    type: 'integer',
+                    description: 'Maximum transactions in atomic group (default: 16)',
+                    default: 16
+                },
+                maxDepth: {
+                    type: 'integer',
+                    description: 'Maximum routing hops (default: 4)',
+                    default: 4
+                }
+            },
+            required: ['fromASAID', 'toASAID', 'amount']
+        })
+    }
+];
+export async function handleSwapTools(args) {
+    const { name, fromASAID, toASAID, amount, slippage = 1, type = 'fixed-input', note, maxGroupSize, maxDepth, } = args;
+    const network = extractNetwork(args);
+    if (network === 'localnet') {
+        throw new McpError(ErrorCode.InvalidRequest, 'Haystack Router is not available on localnet');
+    }
+    if (name === 'api_haystack_execute_swap') {
+        try {
+            // 1. Get active wallet account and secret key
+            const account = await WalletManager.getActiveWalletAccount();
+            const sk = await WalletManager.getActiveWalletSecretKey();
+            const address = account.address;
+            // 2. Create a signer using the wallet's secret key
+            const signer = async (txnGroup, indexesToSign) => {
+                return indexesToSign.map((index) => algosdk.signTransaction(txnGroup[index], sk).blob);
+            };
+            // 3. Get router client and fetch quote
+            const router = getRouterClient(network);
+            const quoteParams = {
+                fromASAID,
+                toASAID,
+                amount: BigInt(amount),
+                type,
+                address,
+            };
+            if (maxGroupSize !== undefined)
+                quoteParams.maxGroupSize = maxGroupSize;
+            if (maxDepth !== undefined)
+                quoteParams.maxDepth = maxDepth;
+            const quote = await router.newQuote(quoteParams);
+            // 4. Check spending limits (estimate based on input amount for ALGO sends)
+            const estimatedSpend = fromASAID === 0 ? Number(amount) : 0;
+            WalletManager.checkWalletSpendingLimits(account, estimatedSpend);
+            // 5. Build and execute swap
+            const swapConfig = {
+                quote,
+                address,
+                signer,
+                slippage,
+            };
+            if (note) {
+                swapConfig.note = new TextEncoder().encode(note);
+            }
+            const swap = await router.newSwap(swapConfig);
+            const result = await swap.execute();
+            // 6. Record spend
+            await WalletManager.recordWalletSpend(address, estimatedSpend);
+            // 7. Get swap summary
+            const summary = swap.getSummary();
+            const inputTxnId = swap.getInputTransactionId();
+            // 8. Build response
+            const response = {
+                status: 'confirmed',
+                confirmedRound: result.confirmedRound.toString(),
+                txIds: result.txIds,
+                signer: address,
+                nickname: account.nickname,
+                network,
+                quote: {
+                    fromASAID: quote.fromASAID,
+                    toASAID: quote.toASAID,
+                    expectedOutput: quote.quote.toString(),
+                    inputAmount: quote.amount.toString(),
+                    type: quote.type,
+                    usdIn: quote.usdIn,
+                    usdOut: quote.usdOut,
+                    userPriceImpact: quote.userPriceImpact,
+                    route: quote.flattenedRoute,
+                },
+                slippage,
+            };
+            if (summary) {
+                response.summary = {
+                    inputAssetId: summary.inputAssetId.toString(),
+                    outputAssetId: summary.outputAssetId.toString(),
+                    inputAmount: summary.inputAmount.toString(),
+                    outputAmount: summary.outputAmount.toString(),
+                    totalFees: summary.totalFees.toString(),
+                    transactionCount: summary.transactionCount,
+                    inputTxnId: summary.inputTxnId,
+                    outputTxnId: summary.outputTxnId,
+                };
+            }
+            if (inputTxnId) {
+                response.inputTransactionId = inputTxnId;
+            }
+            return response;
+        }
+        catch (error) {
+            if (error instanceof McpError)
+                throw error;
+            throw new McpError(ErrorCode.InternalError, `Haystack swap failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    throw new McpError(ErrorCode.MethodNotFound, `Unknown Haystack swap tool: ${name}`);
+}

package/dist/tools/apiManager/index.js

@@ -5,6 +5,7 @@ import { nfdTools, handleNFDTools } from './nfd/index.js';
 import { tinymanTools, handleTinymanTools } from './tinyman/index.js';
 // import { ultradeTools, handleUltradeTools } from './ultrade/index.js';
 import { exampleTools, handleExampleTools } from './example/index.js';
+import { haystackTools, handleHaystackTools } from './hayrouter/index.js';
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
 import { ResponseProcessor } from '../../utils/responseProcessor.js';
 // Combine all API tools
@@ -13,6 +14,7 @@ export const apiManager = [
     ...indexerTools,
     ...nfdTools,
     ...tinymanTools,
+    ...haystackTools,
     ...exampleTools
 ];
 // Handle all API tools
@@ -35,6 +37,10 @@ export async function handleApiManager(name, args) {
         else if (name.startsWith('api_algod_')) {
             response = await handleAlgodTools(name, args);
         }
+        // Haystack Router tools
+        else if (name.startsWith('api_haystack_')) {
+            response = await handleHaystackTools(name, args);
+        }
         else if (name.startsWith('api_example_')) {
             response = await handleExampleTools(name, args);
         }

package/dist/tools/walletManager.d.ts

@@ -1,4 +1,4 @@
-interface AccountRow {
+export interface AccountRow {
     id: number;
     address: string;
     public_key: string;
@@ -42,5 +42,12 @@ export declare class WalletManager {
     static getAccounts(): Promise<AccountRow[]>;
     static hasAccounts(): Promise<boolean>;
     static getActiveAccountInfo(): Promise<AccountRow | null>;
+    /** Get active account details (address, nickname, spending limits). */
+    static getActiveWalletAccount(): Promise<AccountRow>;
+    /** Get active account's secret key from OS keychain. */
+    static getActiveWalletSecretKey(): Promise<Uint8Array>;
+    /** Check if transaction amount is within spending limits. Throws on violation. */
+    static checkWalletSpendingLimits(account: AccountRow, amountMicroAlgos: number): void;
+    /** Record a spend against the account's daily allowance tracker. */
+    static recordWalletSpend(address: string, amountMicroAlgos: number): Promise<void>;
 }
-export {};

package/dist/tools/walletManager.js

@@ -726,6 +726,23 @@ export class WalletManager {
             return null;
         }
     }
+    // ── Public accessors for external tool integration (e.g., haystack-router) ──
+    /** Get active account details (address, nickname, spending limits). */
+    static async getActiveWalletAccount() {
+        return WalletManager.getActiveAccount();
+    }
+    /** Get active account's secret key from OS keychain. */
+    static async getActiveWalletSecretKey() {
+        return WalletManager.getActiveSecretKey();
+    }
+    /** Check if transaction amount is within spending limits. Throws on violation. */
+    static checkWalletSpendingLimits(account, amountMicroAlgos) {
+        return WalletManager.checkSpendingLimits(account, amountMicroAlgos);
+    }
+    /** Record a spend against the account's daily allowance tracker. */
+    static async recordWalletSpend(address, amountMicroAlgos) {
+        return WalletManager.recordSpend(address, amountMicroAlgos);
+    }
 }
 WalletManager.walletTools = [
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goplausible/algorand-mcp",
-  "version": "3.0.7",
+  "version": "3.1.0",
   "publishConfig": {
     "access": "public"
   },
@@ -39,6 +39,7 @@
     "@napi-rs/keyring": "^1.2.0",
     "@noble/curves": "^2.0.1",
     "@tinymanorg/tinyman-js-sdk": "^5.1.2",
+    "@txnlab/haystack-router": "^2.0.5",
     "algo-msgpack-with-bigint": "^2.1.1",
     "algosdk": "^3.5.2",
     "hi-base32": "^0.5.1",