nyxora 26.6.5 → 26.6.6

package/CHANGELOG.md

@@ -5,6 +5,47 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepashangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [26.6.6] - 2026-06-05
+### Enterprise Stability Upgrades
+- **Strict LLM Output Validation**: Added robust try-catch parsing for LLM tool arguments in `reasoning.ts`. If the AI outputs malformed JSON, the error is fed back into the reasoning loop, allowing the model to autonomously self-correct without crashing the agent pipeline.
+- **Transaction Simulation (Dry-Run)**: Integrated `publicClient.estimateGas` in the Signer Vault before broadcasting transactions. This ensures all Web3 transactions are simulated at the node level, preventing users from wasting gas fees on reverted transactions (e.g., due to insufficient slippage or balance).
+- **Graceful Shutdown (Keyring Security)**: Replaced `SIGKILL` with `SIGTERM` in `launcher.ts` and added explicit process termination listeners in the Signer server. When a user exits the CLI using `Ctrl+C`, the system elegantly clears the in-memory `vaultPrivateKey` reference and unlinks unix sockets, securing the local Keyring vault before terminating.
+- **Undefined Function Fix**: Fixed a silent `TypeError` bug in `reasoning.ts` where a failed LLM parsing attempt would call an undefined `executeReasoningLoop` function. Now gracefully loops via standard `logger.addEntry` continuation.
+
+### Bug Fixes & UX Enhancements
+- **Destructive Config Overwrite Fix**: Fixed a critical bug in `/api/config` where saving settings via the Dashboard UI would silently delete the user's Telegram Bot token and system permissions. The API now performs a deep merge with `config.yaml`.
+- **Asynchronous Transaction UI**: Detached the Web3 transaction execution loop from the Dashboard UI `/approve` endpoint. Approvals now instantly return a success state to the UI (preventing 3-minute freezes) while the transaction safely confirms in the background and reports back via chat.
+
+### Performance & Speed Optimizations
+- **SQLite Indexing (O(1) Lookup)**: Added an automatic `CREATE INDEX` for `session_id` in the memory logger database, drastically reducing query latency from O(n) full table scans to instantaneous lookups for large chat histories.
+- **Sliding Window Context Limit**: Overhauled `getHistory()` with an SQL subquery `LIMIT 40` approach. The agent now only feeds the most recent 40 messages to the LLM context, massively reducing API token costs and preventing latency bloat.
+- **Pre-Compiled Runtime (ts-node Elimination)**: Replaced on-the-fly TypeScript compilation (`ts-node`) with ahead-of-time compilation (`tsc`). `launcher.ts` and `nyxora.mjs` now natively detect and execute compiled `.js` files from the `dist/` directory, resulting in near-instant daemon startup times.
+- **Global Token Metadata Cache (OOM Protected)**: Implemented an in-memory Bounded LRU Cache (max 1000 items) in `tokens.ts` for caching `decimals` and `symbol`. This eliminates repetitive RPC calls for immutable token data, shielding the system from Out-Of-Memory crashes if spammed with fake tokens.
+- **Web3 RPC Parallelization**: Refactored `transfer.ts`, `swapToken.ts`, `bridgeToken.ts`, and `getBalance.ts` to replace slow, sequential `readContract` calls with `Promise.all` fetching via `getTokenMetadata()`. Web3 action preparation latency has been reduced to near 0ms for cached tokens.
+
+## [26.6.5-1.0] - 2026-06-05
+### Bug Fixes & Improvements
+- **Transaction Stability**: Added 30-second `AbortSignal` timeout safety net across all Web3 skills (`swapToken`, `transfer`, `bridgeToken`, `mintNft`, `customTx`) to prevent UI hanging when RPC nodes are unresponsive.
+- **Multi-Session Transaction Logs**: Fixed an issue where Web3 transaction status messages (Approve/Reject/Success/Failure) were logged to the `default` session instead of the user's active session window, by attaching the correct `sessionId` with `Content-Type: application/json` headers in dashboard API requests.
+- **UI Tool Rendering Bug**: Fixed a React rendering bug in `App.tsx` where the AI's internal tool execution notification (green bubble) would be hidden if the AI generated both conversational text and a tool execution in the same response.
+- **Base Sepolia Support**: Officially added `base_sepolia` testnet to the supported networks list and `bridgeToken` mappings to prevent AI confusion when resolving bridge destinations.
+- **Default Policy Override (Plug & Play)**: Adjusted the default `config.yaml` template and internal Policy Engine defaults to set `allow_transfer`, `allow_swap`, `allow_shell_execution`, and `allow_file_write` to `true`. Also uncapped `max_usd_per_tx` to `$999,999,999` by default, ensuring a seamless "plug and play" experience for new users without needing manual configuration edits.
+- **Viem RPC Timeout**: Injected a strict 15-second timeout inside the `signer` vault's `viem` HTTP transport to prevent indefinite freezing during blockchain gas estimation when the node is heavily rate-limited.
+- **Auto-Approve Signature Fix**: Added internal HMAC signature generation across all Web3 transaction execution modules (Transfer, Bridge, Mint, CustomTx) to resolve the `Missing internal signature for autoApprove` error during manual dashboard approvals or policy bypasses.
+- **LayerZero Testnet Route**: Upgraded the testnet Bridge mock implementation to utilize LayerZero's V2 Endpoint router (`0x1a44...`) for simulated testnet bridging transactions.
+- **Transaction Result Formatting**: Fixed an issue where the AI would output raw JSON stringified payloads for successful transactions. The chat notification is now properly formatted to clearly display the transaction hash.
+- **Base Sepolia UI Integration**: Synchronized the Dashboard's Network Selector dropdown and Default Web3 Chain settings menu to include the newly added `Base Sepolia (Testnet)` network.
+- **LayerZero Mainnet Removal (Stargate V2)**: Completely removed the experimental LayerZero/Stargate V2 integration from the core bridging engine to prevent interaction with potentially outdated or unverified mainnet smart contracts. Removed the corresponding "LayerZero" routing option from the Dashboard UI dropdown to ensure a highly stable and secure bridging experience exclusively via Li.Fi and Relay.
+- **Relay MEV Protection (Slippage)**: Hardened the `getRelayQuote` HTTP POST request by injecting a strict `slippageTolerance` parameter (default 0.5%). This closes a critical vulnerability where unbounded Relay executions could expose user funds to front-running and MEV attacks during volatile market conditions.
+- **Strict NLP Exactness (Rule 8)**: Injected CRITICAL RULE 8 into the core reasoning pipeline (`reasoning.ts`). The AI is now strictly forbidden from hallucinating or guessing ambiguous transaction parameters (tokens, amounts, or destination networks). It will automatically halt and politely ask the user for explicit clarification before constructing any Web3 payloads.
+- **NLP Context Override System**: Documented the NLP fallback override mechanism in `README.md` and Vitepress documentation to clarify how explicit user chat instructions dynamically bypass Dashboard configurations.
+
+### UI/UX Fixes
+- **Pending Transactions Widget**: Fixed a rendering bug where the Approve/Reject popup was not being injected into the DOM, preventing users from signing transactions.
+
+### Core AI Engine
+- **Strict Language Matching**: Optimized CRITICAL RULE 2 in the System Prompt. The AI now completely ignores historical chat language context and strictly matches the language of the user's latest prompt.
+
 ## [26.6.5] - 2026-06-04 (Hotfix Patch)
 ### Fixed
 - **NPM Monorepo Resolution:** Synced `@inquirer/search` and `duck-duck-scrape` to root `package.json` to prevent `MODULE_NOT_FOUND` and `ERR_CONNECTION_REFUSED` on global installations.

package/README.md

@@ -1,5 +1,5 @@
 # Nyxora Agent 🤖
-**Dual-Engine AI Agent: Bridging On-Chain Execution with Off-Chain Automation.**
+**Your Personal Web3 Assistant.**
 
 
 [![MCP Supported](https://img.shields.io/badge/MCP-Supported-blue.svg)](#)
@@ -27,6 +27,7 @@ It operates under an institutional-grade **Cryptographically Bound Human-in-the-
 
 ### 🌐 Web3 Skills (On-Chain)
 *   **Security Scanner**: Nyxora can scan smart contracts via GoPlus Labs to detect Honeypots, Hidden Taxes, and malicious proxy upgrades before you buy.
+*   **Anti-MEV Slippage Protection**: Hardened routing engine with dynamic Slippage Tolerance (default 0.5%) for Relay and Li.Fi. You can manually adjust slippage via the UI or dynamically override it using natural language (e.g., "Swap 1 ETH to PEPE with 10% slippage").
 *   **Automated Take Profit (TP) & Cut Loss (CL)**: The trader's holy grail. Set natural language rules (e.g., "Sell my PEPE if price drops below $0.001"). Nyxora runs a background cron monitor and executes the swap while you sleep.
 *   **Cross-Chain Hybrid Market Scanner**: Real-time asset tracking combining CoinGecko global data with DexScreener on-chain metrics across Ethereum, Base, Solana, BSC, and more.
 *   **"Lean Degen" Auto-Whitelist**: Automatically intercepts Contract Addresses (CAs) whenever you check balances or swap tokens, saving them to your localized `user_whitelist.json` for future tracking.
@@ -42,6 +43,7 @@ It operates under an institutional-grade **Cryptographically Bound Human-in-the-
 *   **Dynamic Trending Tokens**: Live top 5 crypto assets feed directly injected into the dashboard, completely clickable for instant AI market analysis.
 *   **Premium Utility-Centric UI**: A sleek, dark-themed dashboard built for high readability and professional Web3 execution, featuring Pseudo-Generative UI widgets (`<BalanceWidget>`, `<MarketWidget>`, `<SwapWidget>`).
 *   **Massive 2026 Model Roster**: Out-of-the-box support for cutting-edge models via Google Gemini, OpenAI, Groq, Mistral, xAI, DeepSeek, OpenRouter, and local Ollama, equipped with a searchable CLI prompt to instantly find your favorite model.
+*   **Strict NLP Exactness (Rule 8)**: The AI is rigorously instructed never to hallucinate or guess missing transaction parameters (like destination chains or swap amounts). It halts and requests human clarification, guaranteeing 100% precision.
 *   **Context Overrides Defaults (NLP Intelligence)**: The Dashboard configuration (default chain & router) acts only as a safety net. If you issue an explicit command via Telegram (e.g., *"Swap 10 USDC to USDT on Arbitrum using Li.Fi"*), the NLP engine dynamically bypasses the default settings and executes exactly what you asked for, ensuring maximum flexibility.
 *   **Deep Personalization**: Feed the agent custom rules via `user.md` and define its core persona via `IDENTITY.md`.
 
@@ -107,10 +109,10 @@ npm run build
 # 3. Interactive Setup Wizard (API Keys, Wallet, Telegram)
 npm run setup
 
-# 4. Start the Development Server (Single-Command Boot)
-# This will start the backend vault/services and the frontend Dashboard simultaneously
-npm run dev
+# 4. Start the Application
+npm start
 ```
+*(If you are actively developing and modifying the source code, use `npm run dev` to enable hot-reloading for the frontend and backend).*
 > **⚠️ IMPORTANT:** Whenever you re-run `npm run setup` or manually edit the config files, you **must restart the dev server** for the changes to take effect.
 
 ---

package/SECURITY.md

@@ -78,7 +78,16 @@ To prevent Supply Chain Attacks, the sandbox **permanently blacklists** critical
 *   `child_process`: Plugins cannot spawn silent background terminals or malicious `curl | bash` supply chain payloads.
 *   `os`, `net`, `cluster`: Blocked to prevent network-level exploitation.
 
-## 5. Reporting Vulnerabilities
+## 5. Anti-MEV & Slippage Defense
+
+To protect user funds from front-running and Maximal Extractable Value (MEV) attacks, Nyxora strictly enforces a **Default Slippage Tolerance of 0.5%** for all decentralized exchange (DEX) routing via Li.Fi and Relay.
+
+Unlike typical web3 interfaces that might expose you to unlimited slippage if left unconfigured, Nyxora's backend hardcodes this protection layer into the API payload. 
+If an AI agent attempts to execute a swap without explicit slippage instructions, the `swapToken` and `bridgeToken` engines will automatically inject the `0.5%` boundary. 
+
+Users can safely override this limit globally via the Dashboard UI Settings or dynamically via NLP chat commands for specific high-volatility pairs (e.g., "Swap with 10% slippage").
+
+## 6. Reporting Vulnerabilities
 
 If you discover a vulnerability in the Nyxora architecture, please DO NOT open a public issue.
 Instead, email the core maintainer directly at **ainyxor@gmail.com**.

package/bin/nyxora.mjs

@@ -63,7 +63,14 @@ async function start() {
     } catch(e) {}
   }
 
-  const child = spawn('npx', ['ts-node', '-T', 'launcher.ts'], {
+  const compiledLauncher = path.join(projectRoot, 'dist', 'launcher.js');
+  const useCompiled = fs.existsSync(compiledLauncher);
+  const cmd = useCompiled ? 'node' : 'npx';
+  const args = useCompiled ? [compiledLauncher] : ['ts-node', '-T', 'launcher.ts'];
+
+  if (useCompiled) console.log('⚡ Using pre-compiled JS for blazing fast startup...');
+
+  const child = spawn(cmd, args, {
     cwd: projectRoot,
     detached: true,
     stdio: ['ignore', out, err],
@@ -199,7 +206,25 @@ Comment=Start Nyxora in the background
 
 async function setup() {
   console.log("Running Nyxora Setup Wizard...");
-  const child = spawn('npx', ['ts-node', '-T', 'packages/core/src/gateway/setup-cli.ts'], {
+  const compiledSetup = path.join(projectRoot, 'dist', 'packages/core/src/gateway/setup-cli.js');
+  const useCompiled = fs.existsSync(compiledSetup);
+  const cmd = useCompiled ? 'node' : 'npx';
+  const args = useCompiled ? [compiledSetup] : ['ts-node', '-T', 'packages/core/src/gateway/setup-cli.ts'];
+  const child = spawn(cmd, args, {
+    cwd: projectRoot,
+    stdio: 'inherit',
+    env: { ...process.env, TS_NODE_CACHE: 'false' }
+  });
+  
+  await new Promise(resolve => child.on('close', resolve));
+}
+
+async function clearMemory(cliArgs) {
+  const compiledCli = path.join(projectRoot, 'dist', 'packages/core/src/gateway/cli.js');
+  const useCompiled = fs.existsSync(compiledCli);
+  const cmd = useCompiled ? 'node' : 'npx';
+  const args = useCompiled ? [compiledCli, 'clear', ...cliArgs] : ['ts-node', '-T', 'packages/core/src/gateway/cli.ts', 'clear', ...cliArgs];
+  const child = spawn(cmd, args, {
     cwd: projectRoot,
     stdio: 'inherit',
     env: { ...process.env, TS_NODE_CACHE: 'false' }
@@ -208,8 +233,12 @@ async function setup() {
   await new Promise(resolve => child.on('close', resolve));
 }
 
-async function clearMemory(args) {
-  const child = spawn('npx', ['ts-node', '-T', 'packages/core/src/gateway/cli.ts', 'clear', ...args], {
+async function setKey(cliArgs) {
+  const compiledCli = path.join(projectRoot, 'dist', 'packages/core/src/gateway/cli.js');
+  const useCompiled = fs.existsSync(compiledCli);
+  const cmd = useCompiled ? 'node' : 'npx';
+  const args = useCompiled ? [compiledCli, 'set-key', ...cliArgs] : ['ts-node', '-T', 'packages/core/src/gateway/cli.ts', 'set-key', ...cliArgs];
+  const child = spawn(cmd, args, {
     cwd: projectRoot,
     stdio: 'inherit',
     env: { ...process.env, TS_NODE_CACHE: 'false' }
@@ -222,6 +251,7 @@ async function main() {
   switch (command) {
     case 'setup': await setup(); break;
     case 'clear': await clearMemory(process.argv.slice(3)); break;
+    case 'set-key': await setKey(process.argv.slice(3)); break;
     case 'start': await start(); break;
     case 'stop': await stop(); break;
     case 'restart': await restart(); break;
@@ -238,7 +268,7 @@ async function main() {
       break;
     default:
       console.log(`
-Nyxora CLI Manager
+Nyxora CLI Manager - Your Personal Web3 Assistant
 Usage: nyxora <command>
 
 Commands:
@@ -250,9 +280,11 @@ Commands:
   clear          Atomically clear the AI's short/long-term memory SQLite database
   clean-logs     Clear the daemon logs
   autostart      Enable/disable autostart on boot (usage: nyxora autostart enable)
+  set-key        Securely save API Key (usage: nyxora set-key <provider> <key>)
 
 Options:
   -v, --version  Show current version
+  -h, --help     Show this help menu
 `);
   }
 }

package/dist/packages/core/src/agent/limitOrderManager.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelLimitOrderToolDefinition = exports.listLimitOrdersToolDefinition = exports.createLimitOrderToolDefinition = exports.limitOrderManager = exports.LimitOrderManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const parser_1 = require("../config/parser");
+const paths_1 = require("../config/paths");
+const config_1 = require("../web3/config");
+const tokens_1 = require("../web3/utils/tokens");
+const swapToken_1 = require("../web3/skills/swapToken");
+const transactionManager_1 = require("./transactionManager");
+const reasoning_1 = require("./reasoning");
+class LimitOrderManager {
+    filePath;
+    orders = [];
+    monitorInterval = null;
+    constructor() {
+        const config = (0, parser_1.loadConfig)();
+        this.filePath = (0, paths_1.getPath)(config.memory?.path ? config.memory.path.replace('memory.json', 'orders.json') : 'orders.json');
+        this.loadOrders();
+    }
+    loadOrders() {
+        if (fs_1.default.existsSync(this.filePath)) {
+            try {
+                const data = fs_1.default.readFileSync(this.filePath, 'utf-8');
+                this.orders = JSON.parse(data);
+            }
+            catch (error) {
+                this.orders = [];
+            }
+        }
+    }
+    saveOrders() {
+        try {
+            fs_1.default.writeFileSync(this.filePath, JSON.stringify(this.orders, null, 2));
+        }
+        catch (error) { }
+    }
+    createOrder(chainName, fromToken, toToken, amountStr, targetPriceUsd, condition) {
+        const id = `order_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`;
+        const order = {
+            id, chainName, fromToken, toToken, amountStr, targetPriceUsd, condition, status: 'pending', createdAt: Date.now()
+        };
+        this.orders.push(order);
+        this.saveOrders();
+        return `Limit order created successfully. ID: ${id}. The system will monitor ${fromToken} price on ${chainName} and execute the swap to ${toToken} when price is ${condition} $${targetPriceUsd}.`;
+    }
+    listOrders() {
+        const pending = this.orders.filter(o => o.status === 'pending');
+        if (pending.length === 0)
+            return "No active limit orders.";
+        let report = "Active Limit Orders:\n";
+        pending.forEach(o => {
+            report += `- [${o.id}] Swap ${o.amountStr} ${o.fromToken} -> ${o.toToken} on ${o.chainName} when ${o.fromToken} is ${o.condition} $${o.targetPriceUsd}\n`;
+        });
+        return report;
+    }
+    cancelOrder(id) {
+        const order = this.orders.find(o => o.id === id);
+        if (!order)
+            return `Order ${id} not found.`;
+        if (order.status !== 'pending')
+            return `Order ${id} cannot be cancelled because it is ${order.status}.`;
+        order.status = 'cancelled';
+        this.saveOrders();
+        return `Order ${id} cancelled successfully.`;
+    }
+    startMonitor() {
+        if (this.monitorInterval)
+            clearInterval(this.monitorInterval);
+        // Monitor every 60 seconds
+        this.monitorInterval = setInterval(() => this.checkOrders(), 60000);
+        console.log('[LimitOrderManager] Order monitoring started (interval: 60s)');
+    }
+    async checkOrders() {
+        const pending = this.orders.filter(o => o.status === 'pending');
+        if (pending.length === 0)
+            return;
+        for (const order of pending) {
+            try {
+                let tokenAddress = (0, tokens_1.resolveToken)(order.fromToken, order.chainName);
+                if (tokenAddress === "0x0000000000000000000000000000000000000000") {
+                    tokenAddress = (0, tokens_1.resolveToken)("W" + order.fromToken, order.chainName);
+                }
+                const res = await fetch(`https://api.dexscreener.com/latest/dex/tokens/${tokenAddress}`);
+                if (!res.ok)
+                    continue;
+                const data = await res.json();
+                if (!data.pairs || data.pairs.length === 0)
+                    continue;
+                let pair = data.pairs.find((p) => p.chainId === order.chainName) || data.pairs[0];
+                const currentPrice = parseFloat(pair.priceUsd);
+                let shouldExecute = false;
+                if (order.condition === 'above' && currentPrice >= order.targetPriceUsd)
+                    shouldExecute = true;
+                if (order.condition === 'below' && currentPrice <= order.targetPriceUsd)
+                    shouldExecute = true;
+                if (shouldExecute) {
+                    console.log(`[LimitOrderManager] Condition met for order ${order.id}. Current price $${currentPrice} is ${order.condition} $${order.targetPriceUsd}. Executing...`);
+                    // 1. Prepare Swap
+                    const prepareResult = await (0, swapToken_1.prepareSwapToken)(order.chainName, order.fromToken, order.toToken, order.amountStr, 'auto');
+                    // 2. Extract Tx ID
+                    const txMatch = prepareResult.match(/Transaction ID: ([\w-]+)\./);
+                    if (!txMatch) {
+                        order.status = 'failed';
+                        this.saveOrders();
+                        (0, reasoning_1.processUserInput)(`Limit order ${order.id} execution failed during preparation. Output: ${prepareResult}`, 'system').catch(() => { });
+                        continue;
+                    }
+                    const txId = txMatch[1];
+                    const tx = transactionManager_1.txManager.getTransaction(txId);
+                    if (!tx)
+                        throw new Error("Transaction not found in manager");
+                    // 3. Execute Swap automatically (bypass policy with autoApprove: true)
+                    const executeResult = await (0, swapToken_1.executeSwap)(order.chainName, tx.details, true);
+                    if (executeResult.includes('executed') || executeResult.includes('successful')) {
+                        transactionManager_1.txManager.updateStatus(txId, 'executed', executeResult);
+                        order.status = 'executed';
+                        this.saveOrders();
+                        (0, reasoning_1.processUserInput)(`Limit order ${order.id} just EXECUTED automatically! Price hit $${currentPrice}. Swap result: ${executeResult}. Please notify the user immediately!`, 'system').catch(() => { });
+                    }
+                    else {
+                        transactionManager_1.txManager.updateStatus(txId, 'failed', executeResult);
+                        order.status = 'failed';
+                        this.saveOrders();
+                        (0, reasoning_1.processUserInput)(`Limit order ${order.id} FAILED to execute. Price hit $${currentPrice} but execution failed: ${executeResult}. Please notify the user.`, 'system').catch(() => { });
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`[LimitOrderManager] Error checking order ${order.id}:`, error.message);
+            }
+        }
+    }
+}
+exports.LimitOrderManager = LimitOrderManager;
+exports.limitOrderManager = new LimitOrderManager();
+exports.createLimitOrderToolDefinition = {
+    type: "function",
+    function: {
+        name: "create_limit_order",
+        description: "Creates an automatic cut-loss or take-profit limit order. The system will automatically execute the swap when the price condition is met.",
+        parameters: {
+            type: "object",
+            properties: {
+                chainName: { type: "string", enum: config_1.SUPPORTED_CHAIN_NAMES },
+                fromToken: { type: "string", description: "Token to sell" },
+                toToken: { type: "string", description: "Token to buy" },
+                amountStr: { type: "string", description: "Amount to sell" },
+                targetPriceUsd: { type: "number", description: "Target price in USD for the fromToken" },
+                condition: { type: "string", enum: ["above", "below"], description: "Trigger when price goes above (take-profit) or below (cut-loss) target" }
+            },
+            required: ["chainName", "fromToken", "toToken", "amountStr", "targetPriceUsd", "condition"],
+        },
+    },
+};
+exports.listLimitOrdersToolDefinition = {
+    type: "function",
+    function: {
+        name: "list_limit_orders",
+        description: "Lists all active automated limit orders.",
+        parameters: { type: "object", properties: {}, required: [] },
+    },
+};
+exports.cancelLimitOrderToolDefinition = {
+    type: "function",
+    function: {
+        name: "cancel_limit_order",
+        description: "Cancels an active limit order by ID.",
+        parameters: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"],
+        },
+    },
+};