nyxora 26.6.22-1 → 26.6.24

package/README.md

@@ -2,10 +2,11 @@
 **Your Personal Web3 Assistant.**
 
 
+[![Status: Alpha](https://img.shields.io/badge/Status-Alpha-red.svg)](#)
 [![Built on Arbitrum](https://img.shields.io/badge/Built_on-Arbitrum-28A0F0?style=flat&logo=arbitrum&logoColor=white)](https://arbitrum.io/)
 [![MCP Supported](https://img.shields.io/badge/MCP-Supported-blue.svg)](#)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Security: Production-Grade](https://img.shields.io/badge/Security-Production--Grade-blue.svg)](#️-advanced-security-threat-model)
+[![Security: Defense-in-Depth](https://img.shields.io/badge/Security-Defense--in--Depth-blue.svg)](#️-advanced-security-threat-model)
 [![Execution: Cryptographic Approval](https://img.shields.io/badge/Execution-Cryptographic--Approval-orange.svg)](#️-advanced-security-threat-model)
 [![Privacy: Local-Only Keys](https://img.shields.io/badge/Privacy-Local--Only--Keys-success.svg)](#️-advanced-security-threat-model)
 
@@ -90,7 +91,7 @@ Within the AI Brain, the Web3 codebase is strictly divided to prevent the LLM fr
 
 ## 🛡️ Advanced Security & Threat Model
 
-To dive deeper into the technical details of our Zero-Knowledge security architecture, please visit the [Nyxora Security Blueprint](https://nyxoraai.github.io/Nyxora/).
+To dive deeper into the technical details of our Zero-Knowledge security architecture, please visit the [Nyxora Security](https://nyxoraai.github.io/Nyxora/).
 
 ---
 
@@ -182,8 +183,6 @@ For complete technical deep-dives into our Cryptographic Architecture, please vi
 
 > **🔗 [Read the Full Nyxora Documentation Here](https://nyxoraai.github.io/Nyxora/)**
 
-*(Includes guides on Secure Wallet Imports, Architecture Blueprints, Troubleshooting, and Custom Skill Development).*
-
 ---
 
 **❤️ Support the Project**

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

@@ -37,7 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cronManager = void 0;
-const cron = __importStar(require("node-cron"));
+const croner_1 = require("croner");
 const parser_1 = require("../config/parser");
 const telegram_1 = require("../gateway/telegram");
 const crypto_1 = require("crypto");
@@ -47,10 +47,13 @@ class CronManager {
     addJob(expression, prompt) {
         const id = (0, crypto_1.randomUUID)();
         // Validate expression
-        if (!cron.validate(expression)) {
+        try {
+            new croner_1.Cron(expression);
+        }
+        catch (e) {
             throw new Error(`Invalid cron expression: ${expression}`);
         }
-        const task = cron.schedule(expression, async () => {
+        const task = new croner_1.Cron(expression, async () => {
             console.log(picocolors_1.default.cyan(`[Cron] Executing job ${id}: "${prompt}"`));
             try {
                 // Dynamically import processUserInput to avoid circular dependencies

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

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiAdapter = exports.AnthropicAdapter = exports.OpenAIAdapter = void 0;
+const genai_1 = require("@google/genai");
+class OpenAIAdapter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async chat(request) {
+        const response = await this.client.chat.completions.create(request);
+        return {
+            message: {
+                content: response.choices[0].message.content,
+                tool_calls: response.choices[0].message.tool_calls
+            }
+        };
+    }
+}
+exports.OpenAIAdapter = OpenAIAdapter;
+class AnthropicAdapter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async chat(request) {
+        let systemPrompt = '';
+        const anthropicMessages = [];
+        for (const m of request.messages) {
+            if (m.role === 'system') {
+                systemPrompt = m.content;
+                continue;
+            }
+            if (m.role === 'user') {
+                anthropicMessages.push({ role: 'user', content: m.content });
+            }
+            else if (m.role === 'assistant') {
+                const blocks = [];
+                if (m.content)
+                    blocks.push({ type: 'text', text: m.content });
+                if (m.tool_calls) {
+                    m.tool_calls.forEach((tc) => {
+                        try {
+                            blocks.push({
+                                type: 'tool_use',
+                                id: tc.id,
+                                name: tc.function.name,
+                                input: JSON.parse(tc.function.arguments)
+                            });
+                        }
+                        catch (e) { }
+                    });
+                }
+                anthropicMessages.push({ role: 'assistant', content: blocks.length > 0 ? blocks : m.content });
+            }
+            else if (m.role === 'tool') {
+                anthropicMessages.push({
+                    role: 'user',
+                    content: [
+                        {
+                            type: 'tool_result',
+                            tool_use_id: m.tool_call_id,
+                            content: m.content
+                        }
+                    ]
+                });
+            }
+        }
+        // Merge consecutive roles (Anthropic strictly requires alternating user/assistant)
+        const mergedAnthropic = [];
+        for (const m of anthropicMessages) {
+            const last = mergedAnthropic[mergedAnthropic.length - 1];
+            if (last && last.role === m.role) {
+                if (Array.isArray(last.content) && Array.isArray(m.content)) {
+                    last.content.push(...m.content);
+                }
+                else if (typeof last.content === 'string' && typeof m.content === 'string') {
+                    last.content += '\n\n' + m.content;
+                }
+                else if (Array.isArray(last.content) && typeof m.content === 'string') {
+                    last.content.push({ type: 'text', text: m.content });
+                }
+                else if (typeof last.content === 'string' && Array.isArray(m.content)) {
+                    last.content = [{ type: 'text', text: last.content }, ...m.content];
+                }
+            }
+            else {
+                mergedAnthropic.push(m);
+            }
+        }
+        let anthropicTools = undefined;
+        if (request.tools) {
+            anthropicTools = request.tools.map(t => ({
+                name: t.function.name,
+                description: t.function.description,
+                input_schema: t.function.parameters
+            }));
+        }
+        const response = await this.client.messages.create({
+            model: request.model,
+            system: systemPrompt,
+            messages: mergedAnthropic,
+            tools: anthropicTools,
+            temperature: request.temperature,
+            max_tokens: request.max_tokens || 4096
+        });
+        let contentStr = null;
+        let toolCalls = [];
+        for (const block of response.content) {
+            if (block.type === 'text') {
+                contentStr = (contentStr || '') + block.text;
+            }
+            else if (block.type === 'tool_use') {
+                toolCalls.push({
+                    id: block.id,
+                    type: 'function',
+                    function: {
+                        name: block.name,
+                        arguments: JSON.stringify(block.input)
+                    }
+                });
+            }
+        }
+        return {
+            message: {
+                content: contentStr,
+                tool_calls: toolCalls.length > 0 ? toolCalls : undefined
+            }
+        };
+    }
+}
+exports.AnthropicAdapter = AnthropicAdapter;
+class GeminiAdapter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async chat(request) {
+        let systemInstruction = '';
+        const rawGemini = [];
+        for (const m of request.messages) {
+            if (m.role === 'system') {
+                systemInstruction = m.content;
+                continue;
+            }
+            if (m.role === 'user') {
+                rawGemini.push({ role: 'user', parts: [{ text: m.content }] });
+            }
+            else if (m.role === 'assistant') {
+                const parts = [];
+                if (m.content)
+                    parts.push({ text: m.content });
+                if (m.tool_calls) {
+                    m.tool_calls.forEach((tc) => {
+                        try {
+                            parts.push({
+                                functionCall: {
+                                    name: tc.function.name,
+                                    args: JSON.parse(tc.function.arguments)
+                                }
+                            });
+                        }
+                        catch (e) { }
+                    });
+                }
+                rawGemini.push({ role: 'model', parts: parts });
+            }
+            else if (m.role === 'tool') {
+                rawGemini.push({
+                    role: 'user',
+                    parts: [{
+                            functionResponse: {
+                                name: m.name || 'unknown_tool',
+                                response: { result: m.content }
+                            }
+                        }]
+                });
+            }
+        }
+        const geminiMessages = [];
+        for (const m of rawGemini) {
+            const last = geminiMessages[geminiMessages.length - 1];
+            if (last && last.role === m.role) {
+                last.parts.push(...m.parts);
+            }
+            else {
+                geminiMessages.push(m);
+            }
+        }
+        let tools = undefined;
+        if (request.tools) {
+            tools = [{
+                    functionDeclarations: request.tools.map(t => ({
+                        name: t.function.name,
+                        description: t.function.description,
+                        parameters: t.function.parameters
+                    }))
+                }];
+        }
+        const response = await this.client.models.generateContent({
+            model: request.model,
+            contents: geminiMessages,
+            config: {
+                systemInstruction: systemInstruction,
+                tools: tools,
+                temperature: request.temperature,
+                safetySettings: [
+                    { category: genai_1.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold: genai_1.HarmBlockThreshold.BLOCK_NONE },
+                    { category: genai_1.HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: genai_1.HarmBlockThreshold.BLOCK_NONE },
+                    { category: genai_1.HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold: genai_1.HarmBlockThreshold.BLOCK_NONE },
+                    { category: genai_1.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold: genai_1.HarmBlockThreshold.BLOCK_NONE }
+                ]
+            }
+        });
+        let contentStr = null;
+        let toolCalls = [];
+        if (response.candidates && response.candidates.length > 0) {
+            const candidate = response.candidates[0];
+            // Log finish reason for debugging safety blocks
+            if (candidate.finishReason && candidate.finishReason !== 'STOP') {
+                console.warn(`[LLM] Gemini API returned finishReason: ${candidate.finishReason}`);
+            }
+            if (candidate.content && candidate.content.parts) {
+                const parts = candidate.content.parts;
+                for (const part of parts) {
+                    if (part.text) {
+                        contentStr = (contentStr || '') + part.text;
+                    }
+                    else if (part.functionCall) {
+                        toolCalls.push({
+                            id: `call_${Math.random().toString(36).substring(7)}`,
+                            type: 'function',
+                            function: {
+                                name: part.functionCall.name,
+                                arguments: JSON.stringify(part.functionCall.args)
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            message: {
+                content: contentStr,
+                tool_calls: toolCalls.length > 0 ? toolCalls : undefined
+            }
+        };
+    }
+}
+exports.GeminiAdapter = GeminiAdapter;