hypermind 0.11.0__py3-none-any.whl

hypermind/simlab/tool_handlers/newsapi.py

@@ -0,0 +1,50 @@
+"""NewsAPI headlines handler."""
+
+from __future__ import annotations
+
+import json
+import urllib.parse
+import urllib.request
+from typing import Any
+
+
+async def handle(args: dict[str, Any], credentials: dict[str, str]) -> str:
+    api_key = credentials.get("api_key", "")
+    if not api_key:
+        return json.dumps({"error": "newsapi_headlines: no api_key configured"})
+    qs = urllib.parse.urlencode(
+        {
+            "q": args.get("query", ""),
+            "pageSize": int(args.get("page_size", 5)),
+            "apiKey": api_key,
+            "language": "en",
+            "sortBy": "publishedAt",
+        }
+    )
+    try:
+        with urllib.request.urlopen(f"https://newsapi.org/v2/everything?{qs}", timeout=10) as resp:
+            data = json.loads(resp.read())
+        if data.get("status") != "ok":
+            return json.dumps({"error": data.get("message", "NewsAPI error"), "results": []})
+        articles = [
+            {
+                "title": a.get("title", ""),
+                "url": a.get("url", ""),
+                "description": a.get("description", ""),
+                "publishedAt": a.get("publishedAt", ""),
+            }
+            for a in data.get("articles", [])
+        ]
+        return json.dumps({"query": args.get("query"), "results": articles})
+    except Exception as e:
+        return json.dumps({"error": str(e), "results": []})
+
+
+async def test_connection(credentials: dict[str, str]) -> tuple[bool, str]:
+    try:
+        result = json.loads(await handle({"query": "technology", "page_size": 1}, credentials))
+        if "error" in result:
+            return False, result["error"]
+        return True, f"Connected — {len(result.get('results', []))} article(s)"
+    except Exception as e:
+        return False, str(e)

hypermind/simlab/tool_handlers/openweather.py

@@ -0,0 +1,46 @@
+"""OpenWeatherMap handler."""
+
+from __future__ import annotations
+
+import json
+import urllib.parse
+import urllib.request
+from typing import Any
+
+
+async def handle(args: dict[str, Any], credentials: dict[str, str]) -> str:
+    api_key = credentials.get("api_key", "")
+    if not api_key:
+        return json.dumps({"error": "openweathermap: no api_key configured"})
+    location = args.get("location", "")
+    units = args.get("units", "metric")
+    qs = urllib.parse.urlencode({"q": location, "appid": api_key, "units": units})
+    try:
+        with urllib.request.urlopen(
+            f"https://api.openweathermap.org/data/2.5/weather?{qs}", timeout=10
+        ) as resp:
+            data = json.loads(resp.read())
+        return json.dumps(
+            {
+                "location": data.get("name", location),
+                "country": data.get("sys", {}).get("country", ""),
+                "temperature": data.get("main", {}).get("temp"),
+                "feels_like": data.get("main", {}).get("feels_like"),
+                "humidity": data.get("main", {}).get("humidity"),
+                "description": data.get("weather", [{}])[0].get("description", ""),
+                "wind_speed": data.get("wind", {}).get("speed"),
+                "units": units,
+            }
+        )
+    except Exception as e:
+        return json.dumps({"error": str(e), "location": location})
+
+
+async def test_connection(credentials: dict[str, str]) -> tuple[bool, str]:
+    try:
+        result = json.loads(await handle({"location": "London", "units": "metric"}, credentials))
+        if "error" in result:
+            return False, result["error"]
+        return True, f"Connected — {result.get('location')}: {result.get('temperature')}°C"
+    except Exception as e:
+        return False, str(e)

hypermind/simlab/tool_handlers/pinecone.py

@@ -0,0 +1,52 @@
+"""Pinecone vector search handler."""
+
+from __future__ import annotations
+
+import json
+import urllib.parse
+import urllib.request
+from typing import Any
+
+
+async def handle(args: dict[str, Any], credentials: dict[str, str]) -> str:
+    api_key = credentials.get("api_key", "")
+    index_name = credentials.get("index_name", "")
+    if not api_key or not index_name:
+        return json.dumps({"error": "pinecone_search: api_key and index_name required"})
+    try:
+        req = urllib.request.Request(
+            f"https://api.pinecone.io/indexes/{urllib.parse.quote(index_name)}",
+            headers={"Api-Key": api_key, "Accept": "application/json"},
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            idx_data = json.loads(resp.read())
+        host = idx_data.get("host", "")
+        if not host:
+            return json.dumps({"error": "Could not resolve Pinecone index host", "matches": []})
+        # Query with zero vector (semantic query requires embeddings — return placeholder)
+        return json.dumps(
+            {
+                "query": args.get("query"),
+                "note": "Pinecone requires pre-computed embeddings. Configure an embedding model to enable full semantic search.",
+                "matches": [],
+            }
+        )
+    except Exception as e:
+        return json.dumps({"error": str(e), "matches": []})
+
+
+async def test_connection(credentials: dict[str, str]) -> tuple[bool, str]:
+    api_key = credentials.get("api_key", "")
+    if not api_key:
+        return False, "pinecone_search: api_key required"
+    try:
+        req = urllib.request.Request(
+            "https://api.pinecone.io/indexes",
+            headers={"Api-Key": api_key, "Accept": "application/json"},
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read())
+        indexes = [i.get("name") for i in data.get("indexes", [])]
+        return True, f"Connected — {len(indexes)} index(es): {', '.join(indexes[:3]) or 'none'}"
+    except Exception as e:
+        return False, str(e)

hypermind/simlab/tool_handlers/qdrant.py

@@ -0,0 +1,57 @@
+"""Qdrant vector search handler."""
+
+from __future__ import annotations
+
+import json
+import urllib.parse
+import urllib.request
+from typing import Any
+
+
+async def handle(args: dict[str, Any], credentials: dict[str, str]) -> str:
+    base_url = credentials.get("base_url", "http://localhost:6333").rstrip("/")
+    collection = credentials.get("collection", "")
+    api_key = credentials.get("api_key", "")
+    if not collection:
+        return json.dumps({"error": "qdrant_search: collection name required", "matches": []})
+    headers: dict[str, str] = {"Content-Type": "application/json"}
+    if api_key:
+        headers["api-key"] = api_key
+    # Scroll endpoint to verify connectivity + return note about embeddings
+    try:
+        req = urllib.request.Request(
+            f"{base_url}/collections/{urllib.parse.quote(collection)}/points/scroll",
+            data=json.dumps({"limit": 1, "with_payload": True}).encode(),
+            headers=headers,
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read())
+        return json.dumps(
+            {
+                "query": args.get("query"),
+                "note": "Qdrant requires pre-computed query vectors. Configure an embedding model to enable full semantic search.",
+                "matches": [],
+                "collection_ok": data.get("status") == "ok",
+            }
+        )
+    except Exception as e:
+        return json.dumps({"error": str(e), "matches": []})
+
+
+async def test_connection(credentials: dict[str, str]) -> tuple[bool, str]:
+    base_url = credentials.get("base_url", "http://localhost:6333").rstrip("/")
+    api_key = credentials.get("api_key", "")
+    headers: dict[str, str] = {}
+    if api_key:
+        headers["api-key"] = api_key
+    try:
+        req = urllib.request.Request(f"{base_url}/collections", headers=headers)
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read())
+        collections = [c.get("name") for c in data.get("result", {}).get("collections", [])]
+        return True, f"Connected to Qdrant — {len(collections)} collection(s)"
+    except Exception as e:
+        return False, str(e)
+
+

hypermind/simlab/tool_handlers/query_knowledge_base.py

@@ -0,0 +1,21 @@
+"""HyperMind knowledge base query stub — searches sealed federation claims."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+async def handle(args: dict[str, Any], credentials: dict[str, str]) -> str:
+    query = args.get("query", "")
+    return json.dumps(
+        {
+            "query": query,
+            "matches": [],
+            "note": "HyperMind KB stub — connects to the federation knowledge index in full deployments.",
+        }
+    )
+
+
+async def test_connection(credentials: dict[str, str]) -> tuple[bool, str]:
+    return True, "Stub handler active — no external connection needed"

hypermind/simlab/tool_handlers/relata_recall.py

@@ -0,0 +1,61 @@
+"""Relata memory recall tool — lets agents search their persistent memory during deliberation.
+
+Registered under the name ``relata_recall``. Requires the agent to have a
+:class:`~hypermind.mind.memory_store.RelataMemoryStore` attached via
+:meth:`~hypermind.agent.HyperMindAgent.attach_memory`. Falls back gracefully
+(returns empty list) when no store is attached or RELATA_URL is unset.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def relata_recall() -> dict[str, Any]:
+    """Return an OpenAI-compatible tool definition for Relata memory recall."""
+    return {
+        "type": "function",
+        "function": {
+            "name": "relata_recall",
+            "description": (
+                "Search this agent's persistent memory for past learnings, experiences, "
+                "and research notes. Returns the top-k most relevant items ranked by "
+                "confidence × recency × relevance. Use this BEFORE reasoning about any "
+                "topic to surface what you already know."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Natural-language search query, e.g. 'NK missile test probability'",
+                    },
+                    "top_k": {
+                        "type": "integer",
+                        "description": "Max results to return (1–10, default 5)",
+                        "default": 5,
+                    },
+                },
+                "required": ["query"],
+            },
+        },
+    }
+
+
+def handle_relata_recall(args: dict[str, Any], *, agent: Any = None) -> str:
+    """Execute a relata_recall tool call. agent should be the HyperMindAgent instance."""
+    query = args.get("query", "")
+    top_k = max(1, min(10, int(args.get("top_k", 5))))
+
+    if agent is None or getattr(agent, "_memory", None) is None:
+        return "[]"
+
+    try:
+        rows = agent._memory.recall(query, top_k=top_k)
+        import json
+        return json.dumps(
+            [{"content": r.get("content", ""), "score": r.get("score", 0)} for r in rows],
+            ensure_ascii=False,
+        )
+    except Exception as e:
+        return f"[recall error: {e}]"

hypermind/simlab/tool_handlers/retrieve_document.py

@@ -0,0 +1,21 @@
+"""Built-in document retrieval stub — backwards-compatible with existing tool_affinity."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+async def handle(args: dict[str, Any], credentials: dict[str, str]) -> str:
+    doc_id = args.get("doc_id", "")
+    return json.dumps(
+        {
+            "doc_id": doc_id,
+            "found": False,
+            "note": "Document retrieval stub — configure a real backend handler.",
+        }
+    )
+
+
+async def test_connection(credentials: dict[str, str]) -> tuple[bool, str]:
+    return True, "Stub handler active — no external connection needed"

hypermind/simlab/tool_handlers/serper.py

@@ -0,0 +1,46 @@
+"""Serper (Google) Web Search handler."""
+
+from __future__ import annotations
+
+import json
+import urllib.request
+from typing import Any
+
+
+async def handle(args: dict[str, Any], credentials: dict[str, str]) -> str:
+    api_key = credentials.get("api_key", "")
+    if not api_key:
+        return json.dumps({"error": "serper_web_search: no api_key configured"})
+    payload = json.dumps(
+        {"q": args.get("query", ""), "num": int(args.get("max_results", 5))}
+    ).encode()
+    req = urllib.request.Request(
+        "https://google.serper.dev/search",
+        data=payload,
+        headers={"X-API-KEY": api_key, "Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read())
+        results = [
+            {
+                "title": r.get("title", ""),
+                "url": r.get("link", ""),
+                "description": r.get("snippet", ""),
+            }
+            for r in data.get("organic", [])
+        ]
+        return json.dumps({"query": args.get("query"), "results": results})
+    except Exception as e:
+        return json.dumps({"error": str(e), "results": []})
+
+
+async def test_connection(credentials: dict[str, str]) -> tuple[bool, str]:
+    try:
+        result = json.loads(await handle({"query": "test", "max_results": 1}, credentials))
+        if "error" in result:
+            return False, result["error"]
+        return True, f"Connected — {len(result.get('results', []))} result(s)"
+    except Exception as e:
+        return False, str(e)

hypermind/simlab/tool_handlers/tavily.py

@@ -0,0 +1,53 @@
+"""Tavily AI Search handler."""
+
+from __future__ import annotations
+
+import json
+import urllib.request
+from typing import Any
+
+
+async def handle(args: dict[str, Any], credentials: dict[str, str]) -> str:
+    api_key = credentials.get("api_key", "")
+    if not api_key:
+        return json.dumps({"error": "tavily_search: no api_key configured"})
+    payload = json.dumps(
+        {
+            "api_key": api_key,
+            "query": args.get("query", ""),
+            "max_results": int(args.get("max_results", 5)),
+            "search_depth": "basic",
+        }
+    ).encode()
+    req = urllib.request.Request(
+        "https://api.tavily.com/search",
+        data=payload,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            data = json.loads(resp.read())
+        results = [
+            {
+                "title": r.get("title", ""),
+                "url": r.get("url", ""),
+                "description": r.get("content", "")[:300],
+            }
+            for r in data.get("results", [])
+        ]
+        return json.dumps({"query": args.get("query"), "results": results})
+    except Exception as e:
+        return json.dumps({"error": str(e), "results": []})
+
+
+async def test_connection(credentials: dict[str, str]) -> tuple[bool, str]:
+    try:
+        result = json.loads(
+            await handle({"query": "latest AI news", "max_results": 1}, credentials)
+        )
+        if "error" in result:
+            return False, result["error"]
+        return True, f"Connected — {len(result.get('results', []))} result(s)"
+    except Exception as e:
+        return False, str(e)

hypermind/simlab/tool_handlers/weaviate.py

@@ -0,0 +1,65 @@
+"""Weaviate semantic search handler."""
+
+from __future__ import annotations
+
+import json
+import urllib.parse
+import urllib.request
+from typing import Any
+
+
+async def handle(args: dict[str, Any], credentials: dict[str, str]) -> str:
+    base_url = credentials.get("base_url", "http://localhost:8080").rstrip("/")
+    class_name = credentials.get("class_name", "")
+    api_key = credentials.get("api_key", "")
+    if not class_name:
+        return json.dumps({"error": "weaviate_search: class_name required", "matches": []})
+    headers: dict[str, str] = {"Content-Type": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    graphql_query = json.dumps(
+        {
+            "query": f"""{{
+  Get {{
+    {class_name}(limit: {int(args.get("top_k", 5))}, bm25: {{query: {json.dumps(args.get("query", ""))}}}) {{
+      _additional {{ id score }}
+    }}
+  }}
+}}"""
+        }
+    ).encode()
+    try:
+        req = urllib.request.Request(
+            f"{base_url}/v1/graphql",
+            data=graphql_query,
+            headers=headers,
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read())
+        if "errors" in data:
+            return json.dumps({"error": str(data["errors"]), "matches": []})
+        hits = data.get("data", {}).get("Get", {}).get(class_name, [])
+        return json.dumps(
+            {"query": args.get("query"), "matches": hits[: int(args.get("top_k", 5))]}
+        )
+    except Exception as e:
+        return json.dumps({"error": str(e), "matches": []})
+
+
+async def test_connection(credentials: dict[str, str]) -> tuple[bool, str]:
+    base_url = credentials.get("base_url", "http://localhost:8080").rstrip("/")
+    api_key = credentials.get("api_key", "")
+    headers: dict[str, str] = {}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    try:
+        req = urllib.request.Request(f"{base_url}/v1/schema", headers=headers)
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read())
+        classes = [c.get("class") for c in data.get("classes", [])]
+        return True, f"Connected to Weaviate — {len(classes)} class(es)"
+    except Exception as e:
+        return False, str(e)
+
+

hypermind/simlab/tool_handlers/wikipedia.py

@@ -0,0 +1,64 @@
+"""Wikipedia search handler — no API key required."""
+
+from __future__ import annotations
+
+import json
+import urllib.parse
+import urllib.request
+from typing import Any
+
+_UA = "HyperMindAgent/0.9 (https://github.com/ZySec-AI/hypermind; tool_handler)"
+
+
+async def handle(args: dict[str, Any], credentials: dict[str, str]) -> str:
+    query = args.get("query", "")
+    # Step 1: search for article titles
+    search_qs = urllib.parse.urlencode(
+        {
+            "action": "query",
+            "list": "search",
+            "srsearch": query,
+            "srlimit": int(args.get("max_results", 3)),
+            "format": "json",
+        }
+    )
+    try:
+        req = urllib.request.Request(
+            f"https://en.wikipedia.org/w/api.php?{search_qs}",
+            headers={"User-Agent": _UA},
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            search_data = json.loads(resp.read())
+        hits = search_data.get("query", {}).get("search", [])
+        if not hits:
+            return json.dumps({"query": query, "results": []})
+        results = []
+        for hit in hits[:3]:
+            title = hit.get("title", "")
+            snippet = (
+                hit.get("snippet", "")
+                .replace('<span class="searchmatch">', "")
+                .replace("</span>", "")
+            )
+            results.append(
+                {
+                    "title": title,
+                    "snippet": snippet,
+                    "url": f"https://en.wikipedia.org/wiki/{urllib.parse.quote(title)}",
+                }
+            )
+        return json.dumps({"query": query, "results": results})
+    except Exception as e:
+        return json.dumps({"error": str(e), "query": query, "results": []})
+
+
+async def test_connection(credentials: dict[str, str]) -> tuple[bool, str]:
+    try:
+        result = json.loads(
+            await handle({"query": "artificial intelligence", "max_results": 1}, credentials)
+        )
+        if "error" in result:
+            return False, result["error"]
+        return True, f"Connected — Wikipedia returning {len(result.get('results', []))} result(s)"
+    except Exception as e:
+        return False, str(e)

hypermind/simlab/tool_handlers/wolfram.py

@@ -0,0 +1,48 @@
+"""Wolfram Alpha handler."""
+
+from __future__ import annotations
+
+import json
+import urllib.parse
+import urllib.request
+from typing import Any
+
+
+async def handle(args: dict[str, Any], credentials: dict[str, str]) -> str:
+    api_key = credentials.get("api_key", "")
+    if not api_key:
+        return json.dumps({"error": "wolfram_alpha: no api_key configured"})
+    query = args.get("query", "")
+    qs = urllib.parse.urlencode(
+        {"appid": api_key, "input": query, "output": "json", "format": "plaintext"}
+    )
+    try:
+        with urllib.request.urlopen(
+            f"https://api.wolframalpha.com/v2/query?{qs}", timeout=15
+        ) as resp:
+            data = json.loads(resp.read())
+        if not data.get("queryresult", {}).get("success"):
+            return json.dumps(
+                {"query": query, "answer": None, "error": "No result from Wolfram Alpha"}
+            )
+        pods = data["queryresult"].get("pods", [])
+        answers = []
+        for pod in pods[:4]:
+            title = pod.get("title", "")
+            for sub in pod.get("subpods", []):
+                text = sub.get("plaintext", "").strip()
+                if text:
+                    answers.append({"title": title, "text": text})
+        return json.dumps({"query": query, "answers": answers})
+    except Exception as e:
+        return json.dumps({"error": str(e), "query": query})
+
+
+async def test_connection(credentials: dict[str, str]) -> tuple[bool, str]:
+    try:
+        result = json.loads(await handle({"query": "2+2"}, credentials))
+        if "error" in result:
+            return False, result["error"]
+        return True, "Connected — Wolfram Alpha responding"
+    except Exception as e:
+        return False, str(e)

hypermind/simlab/tool_handlers/yahoo_finance.py

@@ -0,0 +1,49 @@
+"""Yahoo Finance handler — no API key required."""
+
+from __future__ import annotations
+
+import json
+import urllib.parse
+import urllib.request
+from typing import Any
+
+
+async def handle(args: dict[str, Any], credentials: dict[str, str]) -> str:
+    symbol = args.get("symbol", "").upper()
+    period = args.get("period", "1mo")
+    url = f"https://query1.finance.yahoo.com/v8/finance/chart/{urllib.parse.quote(symbol)}?range={period}&interval=1d"
+    headers = {"User-Agent": "Mozilla/5.0"}
+    req = urllib.request.Request(url, headers=headers)
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read())
+        result = data.get("chart", {}).get("result", [])
+        if not result:
+            return json.dumps({"error": f"No data for {symbol}", "symbol": symbol})
+        meta = result[0].get("meta", {})
+        return json.dumps(
+            {
+                "symbol": symbol,
+                "regularMarketPrice": meta.get("regularMarketPrice"),
+                "currency": meta.get("currency"),
+                "exchangeName": meta.get("exchangeName"),
+                "fiftyTwoWeekHigh": meta.get("fiftyTwoWeekHigh"),
+                "fiftyTwoWeekLow": meta.get("fiftyTwoWeekLow"),
+                "period": period,
+            }
+        )
+    except Exception as e:
+        return json.dumps({"error": str(e), "symbol": symbol})
+
+
+async def test_connection(credentials: dict[str, str]) -> tuple[bool, str]:
+    try:
+        result = json.loads(await handle({"symbol": "AAPL", "period": "5d"}, credentials))
+        if "error" in result:
+            return False, result["error"]
+        return (
+            True,
+            f"Connected — AAPL at {result.get('regularMarketPrice', '?')} {result.get('currency', '')}",
+        )
+    except Exception as e:
+        return False, str(e)