nyxora 26.7.2 → 26.7.4

package/dist/packages/core/src/system/skillExtractor.js

@@ -30,11 +30,22 @@ User Intent / Logic: ${userIntent}
 Chat Traces (if any):
 ${historyTraces.join('\n')}
 
-The SKILL.md must contain a YAML frontmatter block with:
-- name: ${safeName}
-- version: 1.0.0
-- description
-- parameters (OpenAI function calling schema format)
+The SKILL.md must contain a YAML frontmatter block exactly following this structure:
+---
+name: ${safeName}
+version: 1.0.0
+description: <Your generated description>
+parameters:
+  type: object
+  properties:
+    param1:
+      type: string
+      description: ...
+  required:
+    - param1
+---
+
+CRITICAL: The 'required' array MUST be indented exactly inside the 'parameters' block as shown above. Do NOT put 'required' at the root level of the YAML.
 
 Do NOT write anything outside the frontmatter except an optional markdown description below it.
 Output ONLY the raw SKILL.md content.`;

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

@@ -3,18 +3,45 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runTerminalCommandToolDefinition = void 0;
 exports.runTerminalCommand = runTerminalCommand;
 const child_process_1 = require("child_process");
+const parser_1 = require("../../config/parser");
 function runTerminalCommand(command) {
     return new Promise((resolve) => {
-        (0, child_process_1.exec)(command, { maxBuffer: 1024 * 1024 * 10 }, (error, stdout, stderr) => {
+        // --- SUDO AUTO-INJECTION ---
+        // If command requires sudo, inject password from config via sudo -S
+        let finalCommand = command;
+        const needsSudo = /^\s*sudo\s/.test(command);
+        if (needsSudo) {
+            try {
+                const config = (0, parser_1.loadConfig)();
+                const sudoPassword = config.security?.sudo_password;
+                if (sudoPassword) {
+                    // Inject password via stdin using echo | sudo -S
+                    const escaped = sudoPassword.replace(/'/g, "'\\''");
+                    finalCommand = command.replace(/^\s*sudo\s/, `echo '${escaped}' | sudo -S `);
+                }
+            }
+            catch (e) {
+                // config load failed, proceed without password injection
+            }
+        }
+        (0, child_process_1.exec)(finalCommand, { maxBuffer: 1024 * 1024 * 10 }, (error, stdout, stderr) => {
             let output = "";
             if (stdout)
                 output += `STDOUT:\n${stdout}\n`;
-            if (stderr)
-                output += `STDERR:\n${stderr}\n`;
+            // Filter out the sudo password prompt noise from stderr
+            const filteredStderr = stderr
+                ? stderr.split('\n').filter(l => !l.includes('[sudo] password for')).join('\n').trim()
+                : '';
+            if (filteredStderr)
+                output += `STDERR:\n${filteredStderr}\n`;
             if (error)
                 output += `ERROR:\n${error.message}\n`;
             if (!output)
                 output = "Command executed successfully with no output.";
+            // If sudo failed due to missing password, give a helpful hint
+            if (needsSudo && (output.includes('sudo: a password is required') || output.includes('no password supplied'))) {
+                output += `\n[NYXORA HINT] To allow Nyxora to run sudo commands automatically, add the following to your ~/.nyxora/config.yaml:\n  security:\n    sudo_password: YOUR_SUDO_PASSWORD\nAlternatively, run this command yourself in a terminal: ${command}`;
+            }
             // --- OUTPUT REDACTION LAYER ---
             // 1. Secret Exfiltration Redaction (Keys, Mnemonics, UUIDs, EVM/Solana Keys)
             const secretPatterns = [
@@ -52,7 +79,7 @@ exports.runTerminalCommandToolDefinition = {
     type: "function",
     function: {
         name: "run_terminal_command",
-        description: "Executes a shell/terminal command on the user's host machine. Use this to install packages, run scripts, manage processes, etc.",
+        description: "Executes a shell/terminal command directly on the LOCAL machine where Nyxora is running — which is the user's own computer. Use this to install packages (apt, pip, npm), run scripts, manage processes, read system info, and automate OS-level tasks. You have full shell access. Do NOT refuse to use this tool by claiming you have no system access.",
         parameters: {
             type: "object",
             properties: {

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

@@ -23,13 +23,15 @@ exports.forgetMemoryToolDefinition = {
 };
 async function forgetMemory(keyword) {
     try {
-        const changes = episodic_1.episodicDB.deleteMemoryByFact(keyword);
-        if (changes > 0) {
+        const memoryChanges = episodic_1.episodicDB.deleteMemoryByFact(keyword);
+        const personaChanges = episodic_1.episodicDB.deletePersonaByTrait(keyword);
+        const totalChanges = memoryChanges + personaChanges;
+        if (totalChanges > 0) {
             await promotionEngine_1.PromotionEngine.runPromotionAndDecay();
-            return `[Success] Deleted ${changes} memory records containing the keyword '${keyword}'. The user.md profile has been synchronized.`;
+            return `[Success] Deleted ${memoryChanges} memory record(s) and ${personaChanges} persona trait(s) containing '${keyword}'. Profile synchronized.`;
         }
         else {
-            return `[Info] No memories found containing the keyword '${keyword}'.`;
+            return `[Info] No memories or persona traits found containing the keyword '${keyword}'.`;
         }
     }
     catch (error) {

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

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readGoogleFormResponsesToolDefinition = exports.readGoogleDocsToolDefinition = exports.appendRowToSheetsToolDefinition = exports.listCalendarEventsToolDefinition = exports.readGmailInboxToolDefinition = void 0;
+exports.addCalendarEventToolDefinition = exports.sendEmailToolDefinition = exports.readGoogleFormResponsesToolDefinition = exports.readGoogleDocsToolDefinition = exports.appendRowToSheetsToolDefinition = exports.listCalendarEventsToolDefinition = exports.readGmailInboxToolDefinition = void 0;
 exports.readGmailInbox = readGmailInbox;
 exports.listCalendarEvents = listCalendarEvents;
 exports.appendRowToSheets = appendRowToSheets;
 exports.readGoogleDocs = readGoogleDocs;
 exports.readGoogleFormResponses = readGoogleFormResponses;
+exports.sendEmail = sendEmail;
+exports.addCalendarEvent = addCalendarEvent;
 const googleAuthModule_1 = require("../../gateway/googleAuthModule");
 async function readGmailInbox(maxResults = 5) {
     const isAuth = await (0, googleAuthModule_1.isAuthenticated)();
@@ -240,3 +242,106 @@ exports.readGoogleFormResponsesToolDefinition = {
         },
     },
 };
+async function sendEmail(to, subject, body) {
+    const isAuth = await (0, googleAuthModule_1.isAuthenticated)();
+    if (!isAuth)
+        return "Google Auth not configured. Please link your Google account in the dashboard.";
+    const token = await (0, googleAuthModule_1.getAccessToken)();
+    if (!token)
+        return "Failed to retrieve access token.";
+    try {
+        const messageParts = [
+            `To: ${to}`,
+            `Subject: ${subject}`,
+            `Content-Type: text/plain; charset=utf-8`,
+            '',
+            body
+        ];
+        const message = messageParts.join('\n');
+        const encodedMessage = Buffer.from(message).toString('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '');
+        const res = await fetch(`https://gmail.googleapis.com/gmail/v1/users/me/messages/send`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ raw: encodedMessage })
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            return `Failed to send email: ${data.error?.message || JSON.stringify(data)}`;
+        }
+        return `Successfully sent email to ${to} with Message ID: ${data.id}`;
+    }
+    catch (err) {
+        return `Error sending email: ${err.message}`;
+    }
+}
+async function addCalendarEvent(summary, description, startTime, endTime) {
+    const isAuth = await (0, googleAuthModule_1.isAuthenticated)();
+    if (!isAuth)
+        return "Google Auth not configured. Please link your Google account in the dashboard.";
+    const token = await (0, googleAuthModule_1.getAccessToken)();
+    if (!token)
+        return "Failed to retrieve access token.";
+    try {
+        const event = {
+            summary,
+            description,
+            start: { dateTime: startTime },
+            end: { dateTime: endTime }
+        };
+        const res = await fetch(`https://www.googleapis.com/calendar/v3/calendars/primary/events`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(event)
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            return `Failed to add calendar event: ${data.error?.message || JSON.stringify(data)}`;
+        }
+        return `Successfully added event '${summary}'. Event link: ${data.htmlLink}`;
+    }
+    catch (err) {
+        return `Error adding calendar event: ${err.message}`;
+    }
+}
+exports.sendEmailToolDefinition = {
+    type: "function",
+    function: {
+        name: "send_email",
+        description: "Sends an email using the user's Gmail account.",
+        parameters: {
+            type: "object",
+            properties: {
+                to: { type: "string", description: "The recipient's email address." },
+                subject: { type: "string", description: "The subject of the email." },
+                body: { type: "string", description: "The plain text body of the email." }
+            },
+            required: ["to", "subject", "body"],
+        },
+    },
+};
+exports.addCalendarEventToolDefinition = {
+    type: "function",
+    function: {
+        name: "add_calendar_event",
+        description: "Adds a new event to the user's primary Google Calendar.",
+        parameters: {
+            type: "object",
+            properties: {
+                summary: { type: "string", description: "The title or summary of the event." },
+                description: { type: "string", description: "A description of the event." },
+                startTime: { type: "string", description: "Start time of the event in ISO 8601 format (e.g. 2026-07-03T09:00:00+07:00)." },
+                endTime: { type: "string", description: "End time of the event in ISO 8601 format (e.g. 2026-07-03T10:00:00+07:00)." }
+            },
+            required: ["summary", "description", "startTime", "endTime"],
+        },
+    },
+};

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/system/skills/searchWeb.js

@@ -139,7 +139,7 @@ async function searchWeb(query, depth = 1) {
     const config = (0, parser_1.loadConfig)();
     const provider = config.web_search?.provider || 'mesh';
     const vaultKeys = await (0, parser_1.loadApiKeys)();
-    const creds = Object.keys(vaultKeys).length > 0 ? vaultKeys : (config.credentials || {});
+    const creds = { ...(config.credentials || {}), ...vaultKeys };
     let results = [];
     try {
         if (provider === 'tavily' && creds.tavily_key) {
@@ -228,11 +228,18 @@ async function searchWeb(query, depth = 1) {
             }
         }
         else {
-            results = await searchSearxng(finalQuery, depth);
+            // Default 'mesh' provider - Prioritize DuckDuckGo as it's more reliable than public SearXNG instances
+            try {
+                results = await searchDuckDuckGo(finalQuery, depth);
+            }
+            catch (e) {
+                console.warn('[WebSearch] Mesh: DuckDuckGo failed. Falling back to SearXNG...');
+                results = await searchSearxng(finalQuery, depth);
+            }
         }
     }
     catch (e) {
-        return `Failed to search the web: ${e.message}`;
+        return `[Search Failed] The web search failed due to an error: ${e.message}. CRITICAL INSTRUCTION: You MUST inform the user that the web search failed. Do NOT hallucinate or guess the answer.`;
     }
     if (results.length > 0) {
         searchCache.set(cacheKey, { data: results, timestamp: Date.now() });
@@ -260,17 +267,17 @@ exports.searchWebToolDefinition = {
     type: "function",
     function: {
         name: "search_web",
-        description: "Searches the internet for information using a search engine. Returns top titles, snippets, and URLs. Use this to find current events, documentation, or general facts. If the user asks for deep/comprehensive research, pass depth: 2 or 3.",
+        description: "Searches the internet for information using a search engine. Returns top titles, snippets, and URLs. CRITICAL: If the user asks for news, sports scores, current events, or factual dates, you MUST set depth: 2 to extract the full article content. Do not use depth 1 for facts.",
         parameters: {
             type: "object",
             properties: {
                 query: {
                     type: "string",
-                    description: "The search query to look up.",
+                    description: "The highly optimized search query to look up (translate to English for global events).",
                 },
                 depth: {
                     type: "number",
-                    description: "Depth of the search (1 for basic, 2 or 3 for deep comprehensive research). Default is 1.",
+                    description: "Depth of the search (1 for basic snippets, 2 for deep scraping of top 3 sites). MUST be 2 for news/scores/facts.",
                 }
             },
             required: ["query"],

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() {