symbolicai 0.17.4__tar.gz → 0.17.6__tar.gz

{symbolicai-0.17.4 → symbolicai-0.17.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symbolicai
-Version: 0.17.4
+Version: 0.17.6
 Summary: A Neurosymbolic Perspective on Large Language Models
 Author-email: Marius-Constantin Dinu <marius@extensity.ai>, Leoveanu-Condrei Claudiu <leo@extensity.ai>
 Project-URL: Homepage, https://extensity.ai

{symbolicai-0.17.4 → symbolicai-0.17.6}/symai/__init__.py

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

symbolicai-0.17.6/symai/backend/engines/search/engine_openai.py

@@ -0,0 +1,238 @@
+import hashlib
+import json
+import logging
+import re
+from copy import deepcopy
+from dataclasses import dataclass
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+from openai import OpenAI
+
+from ....symbol import Result
+from ....utils import CustomUserWarning
+from ...base import Engine
+from ...mixin import OPENAI_CHAT_MODELS, OPENAI_REASONING_MODELS
+from ...settings import SYMAI_CONFIG
+
+logging.getLogger("requests").setLevel(logging.ERROR)
+logging.getLogger("urllib3").setLevel(logging.ERROR)
+logging.getLogger("httpx").setLevel(logging.ERROR)
+logging.getLogger("httpcore").setLevel(logging.ERROR)
+
+
+TRACKING_KEYS = {
+    "utm_source" # so far I've only seen this one
+}
+
+@dataclass
+class Citation:
+    id: str
+    title: str
+    url: str
+    start: int
+    end: int
+
+    def __hash__(self):
+        return hash((self.url, ))
+
+
+class SearchResult(Result):
+    def __init__(self, value, **kwargs) -> None:
+        super().__init__(value, **kwargs)
+        if value.get('error'):
+            CustomUserWarning(value['error'], raise_with=ValueError)
+        try:
+            text, annotations = self._extract_text_and_annotations(value)
+            if text is None:
+                self._value = None
+                self._citations = []
+                return
+            replaced_text, ordered = self._replace_links_with_citations(text, annotations, id_mode="sequential")
+            self._value = replaced_text
+            self._citations = [
+                Citation(id=cid, title=title, url=url, start=0, end=0)
+                for cid, title, url in ordered
+            ]
+
+        except Exception as e:
+            self._value = None
+            CustomUserWarning(f"Failed to parse response: {e}", raise_with=ValueError)
+
+    def _extract_text(self, value) -> str | None:
+        text = None
+        for output in value.get('output', []):
+            if output.get('type') == 'message' and output.get('content'):
+                content0 = output['content'][0]
+                if 'text' in content0 and content0['text']:
+                    text = content0['text']
+        return text
+
+    def _extract_text_and_annotations(self, value):
+        text = None
+        annotations = []
+        for output in value.get('output', []):
+            if output.get('type') != 'message' or not output.get('content'):
+                continue
+            for content in output.get('content', []) or []:
+                if 'text' in content and content['text']:
+                    text = content['text']
+                anns = content.get('annotations', []) or []
+                for ann in anns:
+                    if ann.get('type') == 'url_citation':
+                        annotations.append(ann)
+        return text, annotations
+
+    def _normalize_url(self, u: str) -> str:
+        parts = urlsplit(u)
+        scheme = parts.scheme.lower()
+        netloc = parts.netloc.lower()
+        path = parts.path.rstrip('/') or '/'
+        q = []
+        for k, v in parse_qsl(parts.query, keep_blank_values=True):
+            kl = k.lower()
+            if kl in TRACKING_KEYS or kl.startswith('utm_'):
+                continue
+            q.append((k, v))
+        query = urlencode(q, doseq=True)
+        fragment = ''
+        return urlunsplit((scheme, netloc, path, query, fragment))
+
+    def _make_title_map(self, annotations):
+        m = {}
+        for a in annotations or []:
+            url = a.get('url')
+            if not url:
+                continue
+            nu = self._normalize_url(url)
+            title = (a.get('title') or '').strip()
+            if nu not in m and title:
+                m[nu] = title
+        return m
+
+    def _hostname(self, u: str) -> str:
+        return urlsplit(u).netloc
+
+    def _short_hash_id(self, nu: str, length=6) -> str:
+        return hashlib.sha1(nu.encode('utf-8')).hexdigest()[:length]
+
+    def _replace_links_with_citations(self, text: str, annotations, id_mode: str = 'sequential'):
+        title_map = self._make_title_map(annotations)
+        id_map = {}
+        ordered = []  # list of ("[n]", title, normalized_url)
+        next_id = 1
+
+        pattern = re.compile(r"\[([^\]]*?)\]\((https?://[^\s)]+)\)")
+
+        def _get_id(nu: str) -> str:
+            nonlocal next_id
+            if id_mode == 'hash':
+                return self._short_hash_id(nu)
+            if nu not in id_map:
+                id_map[nu] = str(next_id)
+                t = title_map.get(nu) or self._hostname(nu)
+                ordered.append((f"[{id_map[nu]}]", t, nu))
+                next_id += 1
+            return id_map[nu]
+
+        def _repl(m):
+            link_text, url = m.group(1), m.group(2)
+            nu = self._normalize_url(url)
+            cid = _get_id(nu)
+            title = title_map.get(nu)
+            if not title:
+                lt = (link_text or '').strip()
+                title = lt if (' ' in lt) else self._hostname(nu)
+            return f"[{cid}] ({title})"
+
+        replaced = pattern.sub(_repl, text)
+        return replaced, ordered
+
+    def __str__(self) -> str:
+        try:
+            return json.dumps(self.raw, indent=2)
+        except TypeError:
+            return str(self.raw)
+
+    def _repr_html_(self) -> str:
+        try:
+            return f"<pre>{json.dumps(self.raw, indent=2)}</pre>"
+        except Exception as e:
+            return f"<pre>{str(self.raw)}</pre>"
+
+    def get_citations(self) -> list[Citation]:
+        return self._citations
+
+
+class GPTXSearchEngine(Engine):
+    def __init__(self, api_key: str | None = None, model: str | None = None):
+        super().__init__()
+        self.config = deepcopy(SYMAI_CONFIG)
+        if api_key is not None and model is not None:
+            self.config['SEARCH_ENGINE_API_KEY'] = api_key
+            self.config['SEARCH_ENGINE_MODEL']   = model
+        self.api_key = self.config.get('SEARCH_ENGINE_API_KEY')
+        self.model = self.config.get('SEARCH_ENGINE_MODEL', 'gpt-4.1') # Default to gpt-4.1 as per docs
+        self.name = self.__class__.__name__
+        try:
+            self.client = OpenAI(api_key=self.api_key)
+        except Exception as e:
+            CustomUserWarning(f"Failed to initialize OpenAI client: {e}", raise_with=ValueError)
+
+    def id(self) -> str:
+        if self.config.get('SEARCH_ENGINE_API_KEY') and \
+            self.config.get('SEARCH_ENGINE_MODEL') in OPENAI_CHAT_MODELS + OPENAI_REASONING_MODELS:
+            return 'search'
+        return super().id()  # default to unregistered
+
+    def command(self, *args, **kwargs):
+        super().command(*args, **kwargs)
+        if 'SEARCH_ENGINE_API_KEY' in kwargs:
+            self.api_key = kwargs['SEARCH_ENGINE_API_KEY']
+        if 'SEARCH_ENGINE_MODEL' in kwargs:
+            self.model = kwargs['SEARCH_ENGINE_MODEL']
+
+    def forward(self, argument):
+        messages = argument.prop.prepared_input
+        kwargs = argument.kwargs
+
+        tool_definition = {"type": "web_search_preview"}
+        user_location = kwargs.get('user_location')
+        if user_location:
+            tool_definition['user_location'] = user_location
+        search_context_size = kwargs.get('search_context_size')
+        if search_context_size:
+            tool_definition['search_context_size'] = search_context_size
+
+        self.model = kwargs.get('model', self.model) # Important for MetadataTracker to work correctly
+        payload = {
+            "model": self.model,
+            "input": messages,
+            "tools": [tool_definition],
+            "tool_choice": {"type": "web_search_preview"} if self.model not in OPENAI_REASONING_MODELS else "auto" # force the use of web search tool for non-reasoning models
+        }
+
+        try:
+            res = self.client.responses.create(**payload)
+            res = SearchResult(res.dict())
+        except Exception as e:
+            CustomUserWarning(f"Failed to make request: {e}", raise_with=ValueError)
+
+        metadata = {"raw_output": res.raw}
+        output   = [res]
+
+        return output, metadata
+
+    def prepare(self, argument):
+        system_message = "You are a helpful AI assistant. Be precise and informative." if argument.kwargs.get('system_message') is None else argument.kwargs.get('system_message')
+
+        res = [
+            {
+                "role": "system",
+                "content": system_message
+            },
+            {
+                "role": "user",
+                "content": f"{argument.prop.query}"
+            }
+        ]
+        argument.prop.prepared_input = res

{symbolicai-0.17.4 → symbolicai-0.17.6}/symai/models/base.py

@@ -74,8 +74,6 @@ class LLMDataModel(BaseModel):
         origin = get_origin(field_type)
         return origin in (list, set, frozenset, tuple, dict) or field_type in (list, set, frozenset, tuple, dict)
 
-
-
     @staticmethod
     def _is_const_field(field_info) -> bool:
         """Check if a field is a const field."""
@@ -94,8 +92,6 @@ class LLMDataModel(BaseModel):
         """Check if a field has a default value."""
         return field_info.default != ... and field_info.default != PydanticUndefined
 
-
-
     def format_field(self, key: str, value: Any, indent: int = 0, visited: set = None, depth: int = 0) -> str:
         """Formats a field value for string representation, handling nested structures."""
         visited = visited or set()
@@ -247,7 +243,7 @@ class LLMDataModel(BaseModel):
         definitions = cls._extract_schema_definitions(schema)
 
         main_schema = cls._format_schema_fields(properties, schema, definitions, 0)
-        definitions_schema = cls._format_schema_definitions(definitions)
+        definitions_schema = cls._format_schema_definitions(definitions, schema)
 
         return cls._compose_schema_output(main_schema, definitions_schema)
 
@@ -458,11 +454,65 @@ class LLMDataModel(BaseModel):
         return f"nested object ({ref_name})"
 
     @classmethod
-    def _format_schema_definitions(cls, definitions: dict) -> str:
-        """Format schema definitions using descriptions only; omit redundant types."""
+    def _format_schema_definitions(cls, definitions: dict, root_schema: dict | None = None) -> str:
+        """Format schema definitions using descriptions and examples; omit redundant types.
+
+        Also includes the root model's fields (from root_schema) so their descriptions/examples
+        are visible, not just $defs.
+        """
         lines = []
         visited_defs = set()
 
+        def _format_definition_properties(props: dict) -> list[str]:
+            """Render property lines using only Field(description=...), with const/excerpts.
+
+            Always lists properties; if description is missing, emit a generic guidance message.
+            """
+            out: list[str] = []
+            def _fmt_example_value(val):
+                if isinstance(val, str):
+                    return val
+                try:
+                    return json.dumps(val, ensure_ascii=False)
+                except Exception:
+                    return str(val)
+            for prop_name, prop_schema in props.items():
+                if prop_name == "section_header":
+                    continue
+                desc = prop_schema.get("description")
+                const_note = ""
+                if "const_value" in prop_schema:
+                    const_note = f' (const value: "{prop_schema["const_value"]}")'
+                if not desc:
+                    out.append(
+                        f'  - "{prop_name}": '
+                        'No definition provided. Focus on the [[Schema]] and the prompt to infer '
+                        'the expected structure and constraints.'
+                    )
+                else:
+                    out.append(f'  - "{prop_name}": {desc}{const_note}')
+
+                examples = prop_schema.get("examples")
+                if examples is None and "example" in prop_schema:
+                    examples = prop_schema.get("example")
+
+                if isinstance(examples, (list, tuple)):
+                    if len(examples) > 0:
+                        out.append("    - Examples:")
+                        for ex in examples:
+                            out.append(f"      - {_fmt_example_value(ex)}")
+                elif examples is not None:
+                    out.append(f"    - Example: {_fmt_example_value(examples)}")
+            return out
+
+        # Include root model's fields in Definitions (for descriptions/examples)
+        if root_schema and isinstance(root_schema, dict):
+            root_title = root_schema.get("title", "Root")
+            root_props = cls._extract_schema_properties(root_schema)
+            if root_props:
+                lines.append(f"- {root_title}:")
+                lines.extend(_format_definition_properties(root_props))
+
         for name, definition in definitions.items():
             if name in visited_defs:
                 continue
@@ -475,17 +525,7 @@ class LLMDataModel(BaseModel):
                 continue
 
             props = definition.get("properties", {})
-            for prop_name, prop_schema in props.items():
-                if prop_name == "section_header":
-                    continue
-                desc = prop_schema.get("description") or prop_schema.get("title")
-                if "const_value" in prop_schema:
-                    const_value = prop_schema["const_value"]
-                    const_note = f' (const value: "{const_value}")'
-                else:
-                    const_note = ""
-                if desc:
-                    lines.append(f'  - "{prop_name}": {desc}{const_note}')
+            lines.extend(_format_definition_properties(props))
 
         return "\n".join(lines)
 

{symbolicai-0.17.4 → symbolicai-0.17.6}/symbolicai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symbolicai
-Version: 0.17.4
+Version: 0.17.6
 Summary: A Neurosymbolic Perspective on Large Language Models
 Author-email: Marius-Constantin Dinu <marius@extensity.ai>, Leoveanu-Condrei Claudiu <leo@extensity.ai>
 Project-URL: Homepage, https://extensity.ai

symbolicai-0.17.4/symai/backend/engines/search/engine_openai.py

@@ -1,154 +0,0 @@
-import json
-import logging
-import requests
-from copy import deepcopy
-from dataclasses import dataclass
-
-from ....symbol import Result
-from ....utils import CustomUserWarning
-from ...base import Engine
-from ...settings import SYMAI_CONFIG
-from ...mixin import OPENAI_CHAT_MODELS, OPENAI_REASONING_MODELS
-
-logging.getLogger("requests").setLevel(logging.ERROR)
-logging.getLogger("urllib3").setLevel(logging.ERROR)
-logging.getLogger("httpx").setLevel(logging.ERROR)
-logging.getLogger("httpcore").setLevel(logging.ERROR)
-
-
-@dataclass
-class Citation:
-    id: str
-    title: str
-    url: str
-    start: int
-    end: int
-
-    def __hash__(self):
-        return hash((self.url, ))
-
-
-class SearchResult(Result):
-    def __init__(self, value, **kwargs) -> None:
-        super().__init__(value, **kwargs)
-        if value.get('error'):
-            CustomUserWarning(value['error'], raise_with=ValueError)
-        try:
-            for output in value.get('output', []):
-                if output.get('type') == 'message' and output.get('content'):
-                    annotations = output['content'][0].get('annotations', [])
-                    citations = []
-                    for n, annotation in enumerate(annotations):
-                        if annotation.get('type') == 'url_citation':
-                            citation = Citation(
-                                id=f'[{n + 1}]',
-                                start=annotation.get('start_index'),
-                                end=annotation.get('end_index'),
-                                title=annotation.get('title', ''),
-                                url=annotation.get('url', ''),
-                            )
-                            if citation not in citations:
-                                citations.append(citation)
-            self._value = output['content'][0]['text']
-            delta = 0
-            for citation in citations:
-                self._value = self._value[:citation.start - delta] + citation.id + self._value[citation.end - delta:]
-                delta += (citation.end - citation.start) - len(citation.id)
-            self._citations = citations
-
-        except Exception as e:
-            self._value = None
-            CustomUserWarning(f"Failed to parse response: {e}", raise_with=ValueError)
-
-    def __str__(self) -> str:
-        try:
-            return json.dumps(self.raw, indent=2)
-        except TypeError:
-            return str(self.raw)
-
-    def _repr_html_(self) -> str:
-        try:
-            return f"<pre>{json.dumps(self.raw, indent=2)}</pre>"
-        except Exception as e:
-            return f"<pre>{str(self.raw)}</pre>"
-
-    def get_citations(self) -> list[Citation]:
-        return self._citations
-
-
-class GPTXSearchEngine(Engine):
-    def __init__(self, api_key: str | None = None, model: str | None = None):
-        super().__init__()
-        self.config = deepcopy(SYMAI_CONFIG)
-        if api_key is not None and model is not None:
-            self.config['SEARCH_ENGINE_API_KEY'] = api_key
-            self.config['SEARCH_ENGINE_MODEL']   = model
-        self.api_key = self.config.get('SEARCH_ENGINE_API_KEY')
-        self.model = self.config.get('SEARCH_ENGINE_MODEL', 'gpt-4.1') # Default to gpt-4.1 as per docs
-        self.name = self.__class__.__name__
-
-    def id(self) -> str:
-        if self.config.get('SEARCH_ENGINE_API_KEY') and \
-            self.config.get('SEARCH_ENGINE_MODEL') in OPENAI_CHAT_MODELS + OPENAI_REASONING_MODELS:
-            return 'search'
-        return super().id()  # default to unregistered
-
-    def command(self, *args, **kwargs):
-        super().command(*args, **kwargs)
-        if 'SEARCH_ENGINE_API_KEY' in kwargs:
-            self.api_key = kwargs['SEARCH_ENGINE_API_KEY']
-        if 'SEARCH_ENGINE_MODEL' in kwargs:
-            self.model = kwargs['SEARCH_ENGINE_MODEL']
-
-    def forward(self, argument):
-        messages = argument.prop.prepared_input
-        kwargs = argument.kwargs
-
-        tool_definition = {"type": "web_search_preview"}
-        user_location = kwargs.get('user_location')
-        if user_location:
-            tool_definition['user_location'] = user_location
-        search_context_size = kwargs.get('search_context_size')
-        if search_context_size:
-            tool_definition['search_context_size'] = search_context_size
-
-        self.model = kwargs.get('model', self.model) # Important for MetadataTracker to work correctly
-        payload = {
-            "model": self.model,
-            "input": messages,
-            "tools": [tool_definition],
-            "tool_choice": {"type": "web_search_preview"} # force the use of web search tool
-        }
-
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-            "OpenAI-Beta": "assistants=v1" # Required for some beta features, might be useful
-        }
-        api_url = "https://api.openai.com/v1/responses"
-
-        try:
-            res = requests.post(api_url, json=payload, headers=headers)
-            res = SearchResult(res.json())
-        except Exception as e:
-            CustomUserWarning(f"Failed to make request: {e}", raise_with=ValueError)
-
-        metadata = {"raw_output": res.raw}
-        output   = [res]
-
-        return output, metadata
-
-    def prepare(self, argument):
-        system_message = "You are a helpful AI assistant. Be precise and informative." if argument.kwargs.get('system_message') is None else argument.kwargs.get('system_message')
-
-        res = [
-            {
-                "role": "system",
-                "content": system_message
-            },
-            {
-                "role": "user",
-                "content": f"{argument.prop.query}"
-            }
-        ]
-        argument.prop.prepared_input = res