nyxora 26.7.2 → 26.7.3

package/dist/packages/core/src/system/skills/scheduleTask.js

@@ -18,6 +18,10 @@ exports.scheduleTaskDefinition = {
                 prompt: {
                     type: "string",
                     description: "The prompt/command that the AI should execute when the cron triggers. E.g., 'What is the current price of Ethereum?'"
+                },
+                languageContext: {
+                    type: "string",
+                    description: "Optional. The specific language constraint for the AI's response (e.g., 'Reply strictly in Indonesian informal style', 'Reply in Japanese'). Infer this automatically from the user's current conversation language."
                 }
             },
             required: ["cronExpression", "prompt"]
@@ -25,12 +29,13 @@ exports.scheduleTaskDefinition = {
     }
 };
 async function executeScheduleTask(args) {
-    const { cronExpression, prompt } = args;
+    const { cronExpression, prompt, languageContext } = args;
     if (!cronExpression || !prompt) {
         return "Error: Missing required parameters cronExpression or prompt.";
     }
     try {
-        const jobId = cronManager_1.cronManager.addJob(cronExpression, prompt);
+        const finalPrompt = languageContext ? `${prompt}\n(System Context: ${languageContext})` : prompt;
+        const jobId = cronManager_1.cronManager.addJob(cronExpression, finalPrompt);
         return `Success! I have scheduled the background task.\nJob ID: ${jobId}\nSchedule: ${cronExpression}\nPrompt to execute: "${prompt}"\n\nYou will receive a notification via Telegram every time this task completes.`;
     }
     catch (error) {

package/dist/packages/core/src/test_mainnet.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const providerRegistry_1 = require("./web3/aggregator/providerRegistry");
+const routeSelector_1 = require("./web3/aggregator/routeSelector");
+async function testMainnetSwap(providerName) {
+    try {
+        const req = {
+            fromChain: 'ethereum',
+            toChain: 'ethereum',
+            fromToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+            toToken: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
+            amountInWei: '1000000',
+            amountFormatted: '1',
+            userAddress: '0x1234567890123456789012345678901234567890',
+            slippageTolerance: 50,
+            preferredProvider: providerName
+        };
+        console.log(`\n--- Testing ${providerName} ---`);
+        const quote = await (0, routeSelector_1.fetchBestRoute)(req, "best_output");
+        console.log(`[+] SUCCESS. Provider used: ${quote.provider}`);
+        console.log(`    - execution.target: ${quote.execution.target}`);
+        console.log(`    - approvalAddress: ${quote.approvalAddress || 'MISSING (UNDEFINED)'}`);
+        console.log(`    - execution.value: ${quote.execution.value.toString()} wei (Should be 0 for ERC20)`);
+        if (quote.approvalAddress && quote.approvalAddress.toLowerCase() !== quote.execution.target.toLowerCase()) {
+            console.log(`    ⚠️ WARNING: execution.target DOES NOT MATCH approvalAddress!`);
+        }
+        else if (!quote.approvalAddress) {
+            console.log(`    🚨 CRITICAL: Provider DID NOT return an approvalAddress!`);
+        }
+        if (quote.execution.value > 0n) {
+            console.log(`    🚨 FATAL EXPLOIT: Provider requested native ETH value > 0 for an ERC20 swap!`);
+        }
+    }
+    catch (err) {
+        console.log(`[-] FAILED: ${err.message}`);
+    }
+}
+async function main() {
+    await providerRegistry_1.aggregatorRegistry.autoDiscover();
+    const providers = ['lifi', '0x', 'oneinch', 'kyberswap', 'openocean'];
+    for (const p of providers) {
+        await testMainnetSwap(p);
+    }
+}
+main().catch(console.error);

package/dist/packages/core/src/utils/contextSummarizer.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compressHistory = compressHistory;
+exports.needsCompression = needsCompression;
+/**
+ * Context Summarizer — P6: Prevent Context Window Overflow
+ *
+ * When conversation history grows too long, summarise older messages
+ * into a compact paragraph and return a trimmed history that fits
+ * within a safe token budget. Mirrors the approach used by Claude/GPT
+ * to maintain long-running session coherence.
+ */
+const llmUtils_1 = require("./llmUtils");
+const parser_1 = require("../config/parser");
+const picocolors_1 = __importDefault(require("picocolors"));
+/** How many text-only exchanges to keep verbatim before summarising older ones. */
+const VERBATIM_TAIL = 10;
+/** Minimum history length (user+assistant pairs) before we bother summarising. */
+const SUMMARISE_THRESHOLD = 20;
+/**
+ * Returns a history array that fits in context.
+ * If history is short, returns as-is.
+ * If long, prepends a "Conversation Summary" system message and keeps the tail verbatim.
+ */
+async function compressHistory(history) {
+    const textMessages = history.filter(m => (m.role === 'user' || m.role === 'assistant') && m.content && !m.tool_calls);
+    if (textMessages.length < SUMMARISE_THRESHOLD) {
+        return history; // nothing to compress yet
+    }
+    // Split: old messages to summarise, recent tail to keep verbatim
+    const tailMessages = textMessages.slice(-VERBATIM_TAIL);
+    const oldMessages = textMessages.slice(0, -VERBATIM_TAIL);
+    if (oldMessages.length === 0)
+        return history;
+    try {
+        const config = (0, parser_1.loadConfig)();
+        const historyText = oldMessages
+            .map(m => `${m.role === 'user' ? 'USER' : 'ASSISTANT'}: ${m.content}`)
+            .join('\n');
+        const summaryRes = await (0, llmUtils_1.executeWithRetry)(async (client) => client.chat({
+            model: config.llm.model,
+            temperature: 0.1,
+            messages: [
+                {
+                    role: 'system',
+                    content: `You are a conversation summarizer. Summarize the following conversation exchange into a single concise paragraph (max 200 words). 
+Focus on: key decisions made, important facts established, user preferences expressed, and task outcomes. 
+Write in third person. Be factual, not narrative.`
+                },
+                { role: 'user', content: historyText }
+            ]
+        }));
+        const summaryText = summaryRes.message?.content?.trim() || '';
+        if (!summaryText)
+            return history;
+        console.log(picocolors_1.default.magenta(`[ContextSummarizer] Compressed ${oldMessages.length} old messages into summary.`));
+        // Return: summary as system note + verbatim tail + all tool messages (never drop tool messages)
+        const toolMessages = history.filter(m => m.role === 'tool' || (m.role === 'assistant' && m.tool_calls));
+        return [
+            {
+                role: 'system',
+                content: `--- CONVERSATION SUMMARY (earlier context) ---\n${summaryText}\n--- END SUMMARY ---`
+            },
+            ...tailMessages,
+            ...toolMessages.slice(-6) // keep last 6 tool interactions
+        ];
+    }
+    catch (e) {
+        // On failure, just return the tail — never crash the agent
+        return history.slice(-VERBATIM_TAIL * 2);
+    }
+}
+/**
+ * Fast check — should we attempt compression?
+ */
+function needsCompression(history) {
+    const textCount = history.filter(m => (m.role === 'user' || m.role === 'assistant') && m.content && !m.tool_calls).length;
+    return textCount >= SUMMARISE_THRESHOLD;
+}

package/dist/packages/core/src/utils/skillManager.js

@@ -48,7 +48,7 @@ const reverseSkillMapping = {
     'analyze_market': { category: 'web3', name: 'marketAnalysis' },
     'get_trending_tokens': { category: 'web3', name: 'getTrendingTokens' },
     'manage_custom_tokens': { category: 'web3', name: 'manageCustomTokens' },
-    'get_price': { category: 'web3', name: 'getPrice' },
+    'get_price_and_fiat_value': { category: 'web3', name: 'getPrice' },
     'supply_aave': { category: 'web3', name: 'aaveSupply' },
     'revoke_approval': { category: 'web3', name: 'revokeApproval' },
     'deposit_yield_vault': { category: 'web3', name: 'vaultDeposit' },

package/dist/packages/core/src/utils/streamSimulator.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSmartStreamWrapper = exports.simulateStream = void 0;
+const simulateStream = async (text, onChunk, msPerChunk = 20, charsPerChunk = 3) => {
+    return new Promise((resolve) => {
+        let index = 0;
+        if (!text) {
+            resolve();
+            return;
+        }
+        const intervalId = setInterval(() => {
+            if (index < text.length) {
+                const chunk = text.substring(index, index + charsPerChunk);
+                onChunk(chunk);
+                index += charsPerChunk;
+            }
+            else {
+                clearInterval(intervalId);
+                resolve();
+            }
+        }, msPerChunk);
+    });
+};
+exports.simulateStream = simulateStream;
+/**
+ * Creates a smart wrapper around an onChunk callback.
+ * If the incoming chunk is large (e.g. Gemini buffering), it intercepts it and streams it smoothly.
+ * If the chunk is small (e.g. OpenAI native stream), it passes it instantly.
+ */
+const createSmartStreamWrapper = (originalOnChunk) => {
+    let isSimulating = false;
+    let queue = '';
+    let resolveWait = null;
+    let waitPromise = Promise.resolve();
+    const processQueue = async () => {
+        if (isSimulating || queue.length === 0)
+            return;
+        isSimulating = true;
+        // Create a new wait promise if one doesn't exist
+        if (!resolveWait) {
+            waitPromise = new Promise(r => { resolveWait = r; });
+        }
+        while (queue.length > 0) {
+            const chars = queue.substring(0, 3);
+            queue = queue.substring(3);
+            originalOnChunk(chars);
+            await new Promise(r => setTimeout(r, 20));
+        }
+        isSimulating = false;
+        if (resolveWait) {
+            resolveWait();
+            resolveWait = null;
+        }
+    };
+    let accumulatedRaw = '';
+    let sentLength = 0;
+    return {
+        onChunk: (chunk) => {
+            accumulatedRaw += chunk;
+            // Strip any <think> or <thought> block. 
+            // The (<\/\1>|$) part matches up to the closing tag, or up to the END of the string if it's unclosed.
+            const cleanText = accumulatedRaw.replace(/<(think|thought)[\s\S]*?(<\/\1>|$)/gi, '');
+            if (cleanText.length > sentLength) {
+                const newText = cleanText.substring(sentLength);
+                sentLength = cleanText.length;
+                if (newText.length > 30) {
+                    queue += newText;
+                    processQueue();
+                }
+                else {
+                    if (isSimulating) {
+                        queue += newText;
+                    }
+                    else {
+                        originalOnChunk(newText);
+                    }
+                }
+            }
+        },
+        wait: async () => {
+            await waitPromise;
+        }
+    };
+};
+exports.createSmartStreamWrapper = createSmartStreamWrapper;

package/dist/packages/core/src/web3/aggregator/providers/ArbitrumBridgeProvider.js

@@ -24,7 +24,9 @@ class ArbitrumBridgeProvider {
         return true;
     }
     supports(request) {
-        if (request.fromChain !== 'sepolia' || request.toChain !== 'arbitrum_sepolia')
+        const isL1ToL2 = request.fromChain === 'sepolia' && request.toChain === 'arbitrum_sepolia';
+        const isL2ToL1 = request.toChain === 'sepolia' && request.fromChain === 'arbitrum_sepolia';
+        if (!isL1ToL2 && !isL2ToL1)
             return false;
         const isNative = request.fromToken.toLowerCase() === 'eth' ||
             request.fromToken.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee' ||
@@ -32,27 +34,42 @@ class ArbitrumBridgeProvider {
         return isNative;
     }
     async getQuote(request, context) {
-        const inboxAddress = '0xaAe29B0366299461418F5324a79Afc425BE5ae21';
-        const depositEthAbi = (0, viem_1.parseAbi)(['function depositEth() payable returns (uint256)']);
-        const callData = (0, viem_1.encodeFunctionData)({
-            abi: depositEthAbi,
-            functionName: 'depositEth'
-        });
+        const isL1ToL2 = request.fromChain === 'sepolia';
+        let targetAddress;
+        let callData;
+        if (isL1ToL2) {
+            targetAddress = '0xaAe29B0366299461418F5324a79Afc425BE5ae21'; // Delayed Inbox
+            const depositEthAbi = (0, viem_1.parseAbi)(['function depositEth() payable returns (uint256)']);
+            callData = (0, viem_1.encodeFunctionData)({
+                abi: depositEthAbi,
+                functionName: 'depositEth'
+            });
+        }
+        else {
+            targetAddress = '0x0000000000000000000000000000000000000064'; // ArbSys precompile
+            const withdrawEthAbi = (0, viem_1.parseAbi)(['function withdrawEth(address destination) payable returns (uint256)']);
+            callData = (0, viem_1.encodeFunctionData)({
+                abi: withdrawEthAbi,
+                functionName: 'withdrawEth',
+                args: [request.userAddress]
+            });
+        }
+        const note = isL1ToL2 ? '100% Real L1->L2 Bridge Transaction via Arbitrum Delayed Inbox' : 'Arbitrum ArbSys L2->L1 Withdrawal (Requires ~7 day challenge period)';
         return {
             provider: this.manifest.name,
             routeId: `arb-bridge-${crypto_1.default.randomUUID()}`,
-            fromChainId: 11155111, // Sepolia
-            toChainId: 421614, // Arb Sepolia
+            fromChainId: isL1ToL2 ? 11155111 : 421614,
+            toChainId: isL1ToL2 ? 421614 : 11155111,
             inputAmount: BigInt(request.amountInWei),
             outputAmount: BigInt(request.amountInWei), // 1:1 on official bridge
             executable: true,
             expiresAt: Date.now() + 86400000, // Valid for a long time as it's a fixed contract call
             execution: {
-                target: inboxAddress,
+                target: targetAddress,
                 calldata: callData,
                 value: BigInt(request.amountInWei)
             },
-            raw: { note: '100% Real L1->L2 Bridge Transaction via Arbitrum Delayed Inbox' }
+            raw: { note }
         };
     }
     async isHealthy() {

package/dist/packages/core/src/web3/aggregator/providers/OpBridgeProvider.js

@@ -24,8 +24,9 @@ class OpBridgeProvider {
         return true;
     }
     supports(request) {
-        const isOpStack = request.toChain === 'optimism_sepolia' || request.toChain === 'base_sepolia';
-        if (request.fromChain !== 'sepolia' || !isOpStack)
+        const isL1ToL2 = request.fromChain === 'sepolia' && (request.toChain === 'optimism_sepolia' || request.toChain === 'base_sepolia');
+        const isL2ToL1 = request.toChain === 'sepolia' && (request.fromChain === 'optimism_sepolia' || request.fromChain === 'base_sepolia');
+        if (!isL1ToL2 && !isL2ToL1)
             return false;
         const isNative = request.fromToken.toLowerCase() === 'eth' ||
             request.fromToken.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee' ||
@@ -33,34 +34,47 @@ class OpBridgeProvider {
         return isNative;
     }
     async getQuote(request, context) {
-        // Each OP Stack L2 has its OWN L1StandardBridgeProxy on Sepolia L1
-        // Using the wrong address sends ETH to the wrong contract = loss of funds
-        const BRIDGE_ADDRESSES = {
-            optimism_sepolia: '0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1', // Confirmed: OP Sepolia L1StandardBridgeProxy
-            base_sepolia: '0xfd0Bf71F60660E2f608ed56e1659C450eB113120', // Confirmed: Base Sepolia L1StandardBridgeProxy
-        };
-        const bridgeAddress = BRIDGE_ADDRESSES[request.toChain];
-        if (!bridgeAddress) {
-            throw new Error(`[OpBridgeProvider] No bridge address configured for destination chain: ${request.toChain}`);
+        const isL1ToL2 = request.fromChain === 'sepolia';
+        let bridgeAddress;
+        let callData;
+        if (isL1ToL2) {
+            // L1 to L2
+            const BRIDGE_ADDRESSES = {
+                optimism_sepolia: '0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1',
+                base_sepolia: '0xfd0Bf71F60660E2f608ed56e1659C450eB113120',
+            };
+            bridgeAddress = BRIDGE_ADDRESSES[request.toChain];
+            if (!bridgeAddress) {
+                throw new Error(`[OpBridgeProvider] No bridge address configured for destination chain: ${request.toChain}`);
+            }
+            const depositEthAbi = (0, viem_1.parseAbi)([
+                'function depositETH(uint32 _minGasLimit, bytes _extraData) payable'
+            ]);
+            callData = (0, viem_1.encodeFunctionData)({
+                abi: depositEthAbi,
+                functionName: 'depositETH',
+                args: [200000, '0x']
+            });
+        }
+        else {
+            // L2 to L1
+            bridgeAddress = '0x4200000000000000000000000000000000000010'; // L2StandardBridge predeploy on OP Stack
+            const bridgeEthAbi = (0, viem_1.parseAbi)([
+                'function bridgeETH(uint32 _minGasLimit, bytes _extraData) payable'
+            ]);
+            callData = (0, viem_1.encodeFunctionData)({
+                abi: bridgeEthAbi,
+                functionName: 'bridgeETH',
+                args: [200000, '0x']
+            });
         }
-        // ABI for depositETH
-        const depositEthAbi = (0, viem_1.parseAbi)([
-            'function depositETH(uint32 _minGasLimit, bytes _extraData) payable'
-        ]);
-        // OP Stack requires a minGasLimit. 200000 is a safe default for simple ETH transfers.
-        const minGasLimit = 200000;
-        const extraData = '0x';
-        const callData = (0, viem_1.encodeFunctionData)({
-            abi: depositEthAbi,
-            functionName: 'depositETH',
-            args: [minGasLimit, extraData]
-        });
-        const destChainId = request.toChain === 'optimism_sepolia' ? 11155420 : 84532;
+        const getChainId = (name) => name === 'sepolia' ? 11155111 : (name === 'optimism_sepolia' ? 11155420 : 84532);
+        const note = isL1ToL2 ? 'OP Stack Standard Bridge L1->L2' : 'OP Stack Standard Bridge L2->L1 (Requires 7-day challenge period to finalize)';
         return {
             provider: this.manifest.name,
             routeId: `op-bridge-${crypto_1.default.randomUUID()}`,
-            fromChainId: 11155111,
-            toChainId: destChainId,
+            fromChainId: getChainId(request.fromChain),
+            toChainId: getChainId(request.toChain),
             inputAmount: BigInt(request.amountInWei),
             outputAmount: BigInt(request.amountInWei), // 1:1 bridging
             executable: true,
@@ -70,7 +84,7 @@ class OpBridgeProvider {
                 calldata: callData,
                 value: BigInt(request.amountInWei)
             },
-            raw: { note: 'OP Stack Standard Bridge L1->L2' }
+            raw: { note }
         };
     }
     async isHealthy() {

package/dist/packages/core/src/web3/aggregator/providers/TestnetSwapProvider.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestnetSwapProvider = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+class TestnetSwapProvider {
+    manifest = {
+        id: 'testnet_mock_swap',
+        name: 'Testnet Simulated Swap',
+        version: '1.0.1',
+        networks: ['testnet'],
+        capabilities: ['swap'],
+        allowedDomains: [],
+        permissions: {
+            network: false,
+            walletAccess: 'none',
+            filesystem: 'none'
+        }
+    };
+    isCrossChainSupported() {
+        return false;
+    }
+    supports(request) {
+        if (request.fromChain !== request.toChain)
+            return false;
+        // Only support testnet chains
+        return request.fromChain.includes('sepolia');
+    }
+    async getQuote(request, context) {
+        const chainIds = {
+            sepolia: 11155111,
+            base_sepolia: 84532,
+            optimism_sepolia: 11155420,
+            arbitrum_sepolia: 421614
+        };
+        // Simulate 1:0.98 exchange rate for testing (or a fixed amount if amounts aren't known)
+        // To make it look realistic, we just output 98% of the input conceptually (not accurate for different decimals, but works for mock UX).
+        const outAmount = (BigInt(request.amountInWei) * 98n) / 100n;
+        return {
+            provider: this.manifest.name,
+            routeId: `testnet-swap-${crypto_1.default.randomUUID()}`,
+            fromChainId: chainIds[request.fromChain] || 11155111,
+            toChainId: chainIds[request.toChain] || 11155111,
+            inputAmount: BigInt(request.amountInWei),
+            outputAmount: outAmount,
+            estimatedGasUsd: 0.05,
+            executable: true,
+            expiresAt: Date.now() + 86400000,
+            execution: {
+                // Send a 0 value transaction to the user's own address to simulate contract interaction
+                // without actually losing testnet funds or failing.
+                target: request.userAddress,
+                calldata: '0x',
+                value: 0n
+            },
+            raw: { note: 'Simulated Testnet Swap. Generating a dummy zero-value transaction for UI verification.' }
+        };
+    }
+    async isHealthy() {
+        return { ok: true, checkedAt: Date.now() };
+    }
+}
+exports.TestnetSwapProvider = TestnetSwapProvider;

package/dist/packages/core/src/web3/aggregator/routeSelector.js

@@ -36,7 +36,13 @@ async function fetchBestRoute(request, preference = "best_output") {
     // 1. Resolve eligible providers
     let eligibleProviders = providerRegistry_1.aggregatorRegistry.resolveEligibleProviders(request);
     if (request.preferredProvider && request.preferredProvider !== "auto") {
-        eligibleProviders = eligibleProviders.filter(p => p.manifest.id === request.preferredProvider);
+        const filteredProviders = eligibleProviders.filter(p => p.manifest.id === request.preferredProvider);
+        if (filteredProviders.length > 0) {
+            eligibleProviders = filteredProviders;
+        }
+        else {
+            console.warn(`[RouteSelector] LLM Hallucinated or requested an ineligible provider: '${request.preferredProvider}'. Falling back to automatic provider routing.`);
+        }
     }
     if (eligibleProviders.length === 0) {
         throw new Error('[RouteSelector] No eligible providers found for this route.');

package/dist/packages/core/src/web3/plugins/Web3DefiPlugin.js

@@ -16,7 +16,7 @@ const confirmPendingTx_1 = require("../skills/confirmPendingTx");
 class Web3DefiPlugin {
     name = 'Web3DefiPlugin';
     description = 'Core DeFi operations including balance checking, portfolio analysis, and token swapping.';
-    version = '1.0.0';
+    version = '1.0.1';
     tools = [
         getBalance_1.getBalanceToolDefinition,
         checkPortfolio_1.checkPortfolioToolDefinition,

package/dist/packages/core/src/web3/plugins/Web3MarketPlugin.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Web3MarketPlugin = void 0;
 const httpClient_1 = require("../../utils/httpClient");
-const riskIntelligence_1 = require("../utils/riskIntelligence");
 const marketConfigManager_1 = require("../../config/marketConfigManager");
 async function fetchCexData(symbol) {
     try {
@@ -96,139 +95,20 @@ async function fetchCexMomentum(symbol, currentP) {
         }
     }
 }
+const marketAnalysis_1 = require("../skills/marketAnalysis");
 class Web3MarketPlugin {
     name = 'MarketAnalysis';
-    version = '1.0.0';
+    version = '1.0.1';
     description = 'Provides deep market intelligence and analysis for Web3 assets.';
     tools = [
-        {
-            type: 'function',
-            function: {
-                name: 'analyze_market',
-                description: 'Analyzes the market health of a token (Price, FDV, TVL, Holders, Momentum) by fetching from CEX, DEX, CoinGecko, and DefiLlama. Returns a full intelligence report.',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        tokenAddressOrSymbol: { type: 'string', description: 'The token symbol (e.g. BTC, ETH) or Contract Address.' },
-                        chainName: { type: 'string', description: 'Optional chain name (e.g. ethereum, solana) if searching by address.' }
-                    },
-                    required: ['tokenAddressOrSymbol']
-                }
-            }
-        }
+        marketAnalysis_1.marketAnalysisToolDefinition
     ];
     handlers = {
         'analyze_market': async (args, context) => {
             try {
                 const { chainName, tokenAddressOrSymbol } = args;
-                if (!tokenAddressOrSymbol)
-                    throw new Error("Token symbol is invalid.");
-                const cleanInput = String(tokenAddressOrSymbol || "").replace('$', '').toLowerCase();
-                const isAddress = cleanInput.startsWith('0x') && cleanInput.length === 42;
-                let officialSymbol = cleanInput.toUpperCase();
-                let contractAddress = isAddress ? cleanInput : null;
-                let network = chainName || "UNKNOWN";
-                let currentPrice = 0;
-                let mcapUsd = 0;
-                let liquidityUsd = 0;
-                let volume24h = 0;
-                let priceChange24h = 0;
-                let rsi = null;
-                let ma50 = null;
-                let isCexAsset = false;
-                // PHASE 1
-                if (isAddress) {
-                    const targetPair = await fetchDexData(cleanInput, true, chainName);
-                    if (targetPair) {
-                        officialSymbol = targetPair.baseToken.symbol;
-                        contractAddress = targetPair.baseToken.address;
-                        network = targetPair.chainId.toUpperCase();
-                        currentPrice = parseFloat(targetPair.priceUsd || "0");
-                        mcapUsd = targetPair.fdv || 0;
-                        liquidityUsd = targetPair.liquidity?.usd || 0;
-                        volume24h = targetPair.volume?.h24 || 0;
-                        priceChange24h = targetPair.priceChange?.h24 || 0;
-                    }
-                    else {
-                        return `[Market Intelligence] Failed to find data for Contract Address ${tokenAddressOrSymbol} on DEX.`;
-                    }
-                    const momentum = await fetchCexMomentum(officialSymbol, currentPrice);
-                    ma50 = momentum.ma50;
-                    rsi = momentum.rsi;
-                }
-                else {
-                    const cgData = await fetchCoinGeckoData(officialSymbol);
-                    const cex = await fetchCexData(officialSymbol);
-                    if (cgData || cex) {
-                        isCexAsset = true;
-                        network = `Global CEX/Market`;
-                        currentPrice = cex ? cex.price : (cgData?.price || 0);
-                        volume24h = cgData ? cgData.vol : (cex?.vol || 0);
-                        priceChange24h = cex ? cex.change : (cgData?.change || 0);
-                        mcapUsd = cgData ? cgData.fdv : (volume24h * 10);
-                        liquidityUsd = cgData ? cgData.fdv * 0.1 : (volume24h * 2);
-                        const momentum = await fetchCexMomentum(officialSymbol, currentPrice);
-                        ma50 = momentum.ma50;
-                        rsi = momentum.rsi;
-                    }
-                    else {
-                        const targetPair = await fetchDexData(cleanInput, false, chainName);
-                        if (targetPair) {
-                            officialSymbol = targetPair.baseToken.symbol;
-                            contractAddress = targetPair.baseToken.address;
-                            network = targetPair.chainId.toUpperCase();
-                            currentPrice = parseFloat(targetPair.priceUsd || "0");
-                            mcapUsd = targetPair.fdv || 0;
-                            liquidityUsd = targetPair.liquidity?.usd || 0;
-                            volume24h = targetPair.volume?.h24 || 0;
-                            priceChange24h = targetPair.priceChange?.h24 || 0;
-                        }
-                        else {
-                            return `[Market Intelligence] Failed to find market data for symbol ${officialSymbol} on both CEX and DEX.`;
-                        }
-                    }
-                }
-                // PHASE 2
-                let tvlChange7d = null;
-                try {
-                    const llamaData = await (0, httpClient_1.safeFetchJson)(`https://api.llama.fi/protocol/${officialSymbol.toLowerCase()}`);
-                    if (llamaData && llamaData.tvl) {
-                        const tvlList = llamaData.tvl;
-                        if (tvlList.length > 7) {
-                            const todayTvl = tvlList[tvlList.length - 1].totalLiquidityUSD;
-                            const weekAgoTvl = tvlList[tvlList.length - 8].totalLiquidityUSD;
-                            if (weekAgoTvl > 0)
-                                tvlChange7d = ((todayTvl - weekAgoTvl) / weekAgoTvl) * 100;
-                        }
-                    }
-                }
-                catch { }
-                // PHASE 3
-                let top10HoldersPercent = null;
-                if (contractAddress || isCexAsset) {
-                    if (mcapUsd > 100000000)
-                        top10HoldersPercent = 15;
-                    else if (mcapUsd < 500000)
-                        top10HoldersPercent = 85;
-                    else
-                        top10HoldersPercent = 45;
-                }
-                // PHASE 4
-                const healthResult = (0, riskIntelligence_1.generateMarketHealthReport)(liquidityUsd, mcapUsd, tvlChange7d, volume24h, priceChange24h, top10HoldersPercent, rsi, currentPrice, ma50);
-                // PHASE 5
-                let report = `📊 **Market Intelligence Report: ${officialSymbol}**\n`;
-                report += `CA: \`${contractAddress || 'N/A'}\` | Network: ${network}\n\n`;
-                report += `**⭐ Overall Market Health Score:** ${healthResult.overallScore} / 10\n\n`;
-                report += `**1. Liquidity Risk:** ${healthResult.liquidityScore !== null ? healthResult.liquidityScore + '/10' : '[ N/A ]'}\n`;
-                report += `- Liquidity: $${liquidityUsd.toLocaleString()} vs FDV: $${mcapUsd.toLocaleString()}\n`;
-                report += `**2. Smart Money Flow:** ${healthResult.smartMoneyScore !== null ? healthResult.smartMoneyScore + '/10' : '[ N/A - Not in DefiLlama ]'}\n`;
-                report += `- 24h Volume: $${volume24h.toLocaleString()} | TVL 7D Change: ${tvlChange7d !== null ? tvlChange7d.toFixed(2) + '%' : 'N/A'}\n`;
-                report += `**3. Holder Concentration:** ${healthResult.concentrationScore !== null ? healthResult.concentrationScore + '/10' : '[ N/A - RPC Pending ]'}\n`;
-                report += `- Top 10 Holders: ${top10HoldersPercent !== null ? top10HoldersPercent + '%' : 'N/A'}\n`;
-                report += `**4. Momentum (CEX):** ${healthResult.momentumScore !== null ? healthResult.momentumScore + '/10' : '[ N/A - DEX Only Coin ]'}\n`;
-                report += `- Price: $${currentPrice} | MA50: ${ma50 ? '$' + ma50.toFixed(4) : 'N/A'} | RSI: ${rsi || 'N/A'}\n\n`;
-                report += `*System Note for LLM: Use this exact data to provide a "Market Summary" and "Suggested Autonomous Actions" in the user's native language. If CEX momentum is N/A, explicitly warn about high risk Degen/Memecoin status. IMPORTANT: Always include a clear disclaimer at the end (translated into the user's native language) stating that this analysis is NOT financial advice (NFA).*`;
-                return report;
+                const { analyzeMarket } = require('../skills/marketAnalysis');
+                return await analyzeMarket(chainName, tokenAddressOrSymbol);
             }
             catch (error) {
                 return `[Market Intelligence] Failed to aggregate data: ${error.message}`;