mycelium-js 0.1.0

package/index.js

@@ -0,0 +1,87 @@
+/**
+ * 🍄 US Neural: Mycelium JavaScript SDK
+ * Drop-in semantic routing for Node.js and Browser AI apps.
+ */
+
+export class MyceliumClient {
+    constructor(baseUrl = "http://127.0.0.1:8000/api/v1") {
+        this.baseUrl = baseUrl;
+    }
+
+    /**
+     * Register a tool or agent to the Mycelium Semantic Registry.
+     */
+    async registerTool(agentId, name, description, tags = []) {
+        try {
+            const response = await fetch(`${this.baseUrl}/agents/register`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    agent_id: agentId,
+                    name: name,
+                    description: description,
+                    tags: tags
+                })
+            });
+            return await response.json();
+        } catch (error) {
+            console.error(`🍄 [Mycelium Error] Registration failed: ${error.message}`);
+            return null;
+        }
+    }
+
+    /**
+     * Discover the best tool based on pure user intent.
+     */
+    async discoverTool(userQuery, minScore = 0.15) {
+        try {
+            const url = new URL(`${this.baseUrl}/agents/discover`);
+            url.searchParams.append("q", userQuery);
+            url.searchParams.append("semantic", "true");
+            url.searchParams.append("limit", "1");
+
+            const response = await fetch(url);
+            const data = await response.json();
+
+            if (data.agents && data.agents.length > 0) {
+                const topAgent = data.agents[0];
+                if ((topAgent._similarity_score || 0) >= minScore) {
+                    return topAgent;
+                }
+            }
+            return null;
+        } catch (error) {
+            console.error(`🍄 [Mycelium Error] Discovery failed: ${error.message}`);
+            return null;
+        }
+    }
+
+    /**
+     * The Magic Function: Matches semantic intent with actual JS functions/tools.
+     */
+    async routeAndExecute(userQuery, availableTools) {
+        const bestToolMeta = await this.discoverTool(userQuery);
+
+        if (!bestToolMeta) {
+            return { error: "No suitable tool found for your request." };
+        }
+
+        const targetToolName = bestToolMeta.name;
+        const confidence = bestToolMeta._similarity_score;
+
+        // Find the matching tool in the JS array
+        const tool = availableTools.find(
+            (t) => t.name.toLowerCase() === targetToolName.toLowerCase()
+        );
+
+        if (tool && typeof tool.execute === 'function') {
+            return {
+                toolName: targetToolName,
+                confidence: confidence,
+                result: await tool.execute(userQuery)
+            };
+        }
+
+        return { error: `Tool '${targetToolName}' discovered but not loaded in memory.` };
+    }
+}

package/mycelium.js

@@ -0,0 +1,60 @@
+/**
+ * Mycelium JavaScript SDK v0.1.0
+ * The networking protocol for AI agents.
+ */
+
+class MyceliumClient {
+    constructor(baseUrl = "https://usaai-us-neural-registry.hf.space") {
+        this.baseUrl = baseUrl;
+    }
+
+    /**
+     * Discover agents using semantic search
+     */
+    async discover(query, limit = 5) {
+        try {
+            const url = `${this.baseUrl}/api/v1/discover?q=${encodeURIComponent(query)}&limit=${limit}`;
+            const response = await fetch(url);
+            const data = await response.json();
+            return data.results || data.agents || [];
+        } catch (error) {
+            console.error("🍄 [Mycelium] Discovery failed:", error);
+            return [];
+        }
+    }
+
+    /**
+     * Send a message to another agent
+     */
+    async sendMessage(toAgentId, capability, inputs = {}) {
+        const payload = {
+            envelope: {
+                to_agent: toAgentId,
+                message_type: "request",
+                protocol_version: "0.2.0",
+                timestamp: new Date().toISOString()
+            },
+            payload: {
+                capability: capability,
+                inputs: inputs
+            }
+        };
+
+        try {
+            const response = await fetch(`${this.baseUrl}/api/v1/messages/send`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload)
+            });
+            return await response.json();
+        } catch (error) {
+            console.error("🍄 [Mycelium] Message relay failed:", error);
+            throw error;
+        }
+    }
+}
+
+// Export for Node.js or Browser
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = { MyceliumClient };
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "mycelium-js",
+  "version": "0.1.0",
+  "description": "US Neural: Semantic Tool Registry SDK for JavaScript",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "node test.js"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "semantic",
+    "routing",
+    "usneural",
+    "llm",
+    "orchestration"
+  ],
+  "author": "US Neural",
+  "license": "MIT"
+}

package/sdk-js/index.html

@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Mycelium JS Test</title>
+    <style>
+        body { background: #0f172a; color: white; font-family: sans-serif; padding: 40px; }
+        #results { background: #1e293b; padding: 20px; border-radius: 8px; margin-top: 20px; }
+        .agent { color: #38bdf8; font-weight: bold; }
+    </style>
+</head>
+<body>
+    <h1>🍄 Mycelium JS Explorer</h1>
+    <input type="text" id="query" placeholder="Search capability (e.g. weather)..." style="padding: 10px; width: 300px;">
+    <button onclick="search()" style="padding: 10px 20px; cursor: pointer;">Discover</button>
+
+    <div id="results">Enter a query to find agents on the global network...</div>
+
+    <script src="mycelium.js"></script>
+    <script>
+        const client = new MyceliumClient();
+        
+        async function search() {
+            const q = document.getElementById('query').value;
+            const resDiv = document.getElementById('results');
+            resDiv.innerHTML = "Searching global swarm...";
+            
+            const agents = await client.discover(q);
+            
+            if (agents.length === 0) {
+                resDiv.innerHTML = "❌ No agents found.";
+                return;
+            }
+
+            resDiv.innerHTML = agents.map(a => `
+                <div style="margin-bottom: 15px;">
+                    <span class="agent">${a.name}</span> (${a.agent_id})<br>
+                    <small style="color: #94a3b8;">Caps: ${JSON.stringify(a.capabilities.map(c => c.name || c))}</small>
+                </div>
+            `).join('');
+        }
+    </script>
+</body>
+</html>

package/test.js

@@ -0,0 +1,44 @@
+import { MyceliumClient } from './index.js';
+
+async function runTest() {
+    console.log("🍄 Starting US Neural JS SDK Test...\n");
+    const client = new MyceliumClient();
+
+    // 1. Define our JS Tools
+    const tools = [
+        {
+            name: "ForexAgent",
+            description: "Convert currency and get exchange rates",
+            execute: async (q) => "EUR/USD is 1.09 today."
+        },
+        {
+            name: "WeatherBot",
+            description: "Get local climate info and temperature",
+            execute: async (q) => "It's 22°C and sunny."
+        }
+    ];
+
+    // 2. Register them to the local mesh
+    console.log("Registering JS tools to Mycelium...");
+    for (const tool of tools) {
+        await client.registerTool(tool.name.toLowerCase(), tool.name, tool.description);
+    }
+    
+    // 3. Test Semantic Routing via JS
+    const query = "how many euros will I get for my dollars?";
+    console.log(`\nUser Intent: '${query}'`);
+    
+    const startTime = performance.now();
+    const response = await client.routeAndExecute(query, tools);
+    const latency = performance.now() - startTime;
+
+    if (response.toolName) {
+        console.log(`✅ Routed to: ${response.toolName} (Confidence: ${(response.confidence * 100).toFixed(1)}%)`);
+        console.log(`⚡ Latency: ${latency.toFixed(2)} ms`);
+        console.log(`📤 Tool Output: ${response.result}`);
+    } else {
+        console.log(`❌ Failed: ${response.error}`);
+    }
+}
+
+runTest();