symbolicai 0.20.0__tar.gz → 0.20.2__tar.gz

{symbolicai-0.20.0 → symbolicai-0.20.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symbolicai
-Version: 0.20.0
+Version: 0.20.2
 Summary: A Neurosymbolic Perspective on Large Language Models
 Author-email: Marius-Constantin Dinu <marius@extensity.ai>, Leoveanu-Condrei Claudiu <leo@extensity.ai>
 License: BSD 3-Clause License

{symbolicai-0.20.0 → symbolicai-0.20.2}/docs/source/ENGINES/search_engine.md

@@ -79,6 +79,16 @@ res = search("What local events are happening today?",
 
 # Control the amount of search context
 res = search("Explain quantum computing developments")
+
+# Enable a reasoning model via the Responses API
+res = search(
+    "Summarize the latest research on quantum error correction",
+    model="o4-mini",
+    reasoning={
+        "effort": "medium",
+        "summary": "auto"
+    }
+)
 ```
 
 Here's how to configure the OpenAI search engine:
@@ -91,3 +101,5 @@ Here's how to configure the OpenAI search engine:
     …
 }
 ```
+
+This engine calls the OpenAI Responses API under the hood. When you target a reasoning-capable model, pass a `reasoning` dictionary matching the Responses payload schema (for example `{"effort": "low", "summary": "auto"}`). If omitted, the engine falls back to the default effort/summary settings shown above.

{symbolicai-0.20.0 → symbolicai-0.20.2}/symai/__init__.py

@@ -33,7 +33,7 @@ os.environ['TOKENIZERS_PARALLELISM'] = "false"
 # Create singleton instance
 config_manager = settings.SymAIConfig()
 
-SYMAI_VERSION = "0.20.0"
+SYMAI_VERSION = "0.20.2"
 __version__   = SYMAI_VERSION
 __root_dir__  = config_manager.config_dir
 

{symbolicai-0.20.0 → symbolicai-0.20.2}/symai/backend/engines/search/engine_openai.py

@@ -230,6 +230,8 @@ class SearchResult(Result):
 
 
 class GPTXSearchEngine(Engine):
+    MAX_ALLOWED_DOMAINS = 20
+
     def __init__(self, api_key: str | None = None, model: str | None = None):
         super().__init__()
         self.config = deepcopy(SYMAI_CONFIG)
@@ -250,6 +252,65 @@ class GPTXSearchEngine(Engine):
             return 'search'
         return super().id()  # default to unregistered
 
+    def _extract_netloc(self, raw_domain: str | None) -> str | None:
+        if not isinstance(raw_domain, str):
+            return None
+        candidate = raw_domain.strip()
+        if not candidate:
+            return None
+        parsed = urlsplit(candidate if '://' in candidate else f"//{candidate}")
+        netloc = parsed.netloc or parsed.path
+        if not netloc:
+            return None
+        if '@' in netloc:
+            netloc = netloc.split('@', 1)[1]
+        if ':' in netloc:
+            netloc = netloc.split(':', 1)[0]
+        netloc = netloc.strip('.').strip()
+        if not netloc:
+            return None
+        return netloc.lower()
+
+    def _normalize_allowed_domains(self, domains: list[str] | None) -> list[str]:
+        if not domains or not isinstance(domains, list):
+            return []
+
+        normalized: list[str] = []
+        seen: set[str] = set()
+        for domain in domains:
+            netloc = self._extract_netloc(domain)
+            if not netloc or netloc in seen:
+                continue
+            # Validate that netloc is actually a valid domain
+            if not self._is_domain(netloc):
+                continue
+            normalized.append(netloc)
+            seen.add(netloc)
+            if len(normalized) >= self.MAX_ALLOWED_DOMAINS:
+                break
+        return normalized
+
+    def _is_domain(self, s: str) -> bool:
+        _label_re = re.compile(r"^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?$")
+        if not s:
+            return False
+        host = s.strip().rstrip(".")
+        # If the input might be a URL, extract the hostname via urllib:
+        if "://" in host or "/" in host or "@" in host:
+            host = urlsplit(host if "://" in host else f"//{host}").hostname or ""
+        if not host:
+            return False
+        try:
+            host_ascii = host.encode("idna").decode("ascii")
+        except Exception:
+            return False
+        if len(host_ascii) > 253:
+            return False
+        labels = host_ascii.split(".")
+        if len(labels) < 2:  # require a dot (reject "google")
+            return False
+        return all(_label_re.fullmatch(lbl or "") for lbl in labels)
+
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
         if 'SEARCH_ENGINE_API_KEY' in kwargs:
@@ -266,7 +327,14 @@ class GPTXSearchEngine(Engine):
         if user_location:
             tool_definition['user_location'] = user_location
 
+        allowed_domains = self._normalize_allowed_domains(kwargs.get('allowed_domains'))
+        if allowed_domains:
+            tool_definition['filters'] = {
+                'allowed_domains': allowed_domains
+            }
+
         self.model = kwargs.get('model', self.model) # Important for MetadataTracker to work correctly
+
         payload = {
             "model": self.model,
             "input": messages,
@@ -274,6 +342,10 @@ class GPTXSearchEngine(Engine):
             "tool_choice": {"type": "web_search"} if self.model not in OPENAI_REASONING_MODELS else "auto" # force the use of web search tool for non-reasoning models
         }
 
+        if self.model in OPENAI_REASONING_MODELS:
+            reasoning = kwargs.get('reasoning', { "effort": "low", "summary": "auto" })
+            payload['reasoning'] = reasoning
+
         try:
             res = self.client.responses.create(**payload)
             res = SearchResult(res.dict())

{symbolicai-0.20.0 → symbolicai-0.20.2}/symbolicai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symbolicai
-Version: 0.20.0
+Version: 0.20.2
 Summary: A Neurosymbolic Perspective on Large Language Models
 Author-email: Marius-Constantin Dinu <marius@extensity.ai>, Leoveanu-Condrei Claudiu <leo@extensity.ai>
 License: BSD 3-Clause License

{symbolicai-0.20.0 → symbolicai-0.20.2}/tests/engines/search/openai_engine.py

@@ -1,5 +1,6 @@
 import os
 import re
+from urllib.parse import urlparse
 
 import pytest
 
@@ -17,13 +18,12 @@ def _get_api_key():
     )
 
 
-@pytest.mark.parametrize("model", ["gpt-4.1-mini", "gpt-5-mini"])
+@pytest.mark.parametrize("model", ["gpt-4.1-mini", "gpt-5-nano"])
 def test_openai_search_citations_and_formatting_live(model):
     api_key = _get_api_key()
     if not api_key:
         pytest.skip("OPENAI_API_KEY/SEARCH_ENGINE_API_KEY not set; live test skipped")
 
-    # Register a fresh engine instance with the provided API key and target model
     engine = GPTXSearchEngine(api_key=api_key, model=model)
     EngineRepository.register("search", engine, allow_engine_override=True)
 
@@ -56,3 +56,27 @@ def test_openai_search_citations_and_formatting_live(model):
 
     # 3) Formatting: At least one marker pattern with newline is present
     assert re.search(r"\[\d+\] \([^)]+\)\n", res.value)
+
+
+@pytest.mark.parametrize("model", ["gpt-4.1", "gpt-5-nano"])
+def test_openai_search_domain_filtering(model):
+    api_key = _get_api_key()
+    if not api_key:
+        pytest.skip("OPENAI_API_KEY/SEARCH_ENGINE_API_KEY not set; live test skipped")
+
+    engine = GPTXSearchEngine(api_key=api_key, model=model)
+    EngineRepository.register("search", engine, allow_engine_override=True)
+
+    domains =  [
+        "tomshardware.com",            # ok
+        "https://www.arstechnica.com", # ok, but the internal processing should yield the root domain
+        "tomshardware"                 # not ok
+    ]
+
+    query = "what is the best gpu"
+    search = openai_search()
+    res = search(query, model=model, allowed_domains=domains)
+
+    allowed_netlocs = { "www.tomshardware.com", "www.arstechnica.com" }
+    citation_netlocs = { urlparse(c.url).netloc for c in res.get_citations() }
+    assert allowed_netlocs & citation_netlocs, "No citations from allowed domains found"