symbolicai 0.17.5__tar.gz → 0.18.0__tar.gz

{symbolicai-0.17.5 → symbolicai-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symbolicai
-Version: 0.17.5
+Version: 0.18.0
 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.5 → symbolicai-0.18.0}/docs/source/ENGINES/neurosymbolic_engine.md

@@ -197,6 +197,16 @@ data = json.loads(resp.value)
 # data == {"team":"Los Angeles Dodgers", "year":2020, "coach":"Dave Roberts"}
 ```
 
+### Groq JSON mode caveat
+
+Groq currently has a quirk (arguably a bug) when combining JSON Object Mode with an explicit `tool_choice: "none"`. Their API may return:
+
+```
+Error code: 400 - {'error': {'message': 'Tool choice is none, but model called a tool', 'type': 'invalid_request_error', 'code': 'tool_use_failed', 'failed_generation': '{"name": "<|constrain|>json" …'}}
+```
+
+This happens because JSON Object Mode internally invokes a JSON “constrainer” tool (`<|constrain|>json`), which collides with `tool_choice: "none"`. Groq’s own docs state JSON modes can’t be mixed with tool use; here, the model implicitly “uses a tool” even when you didn’t ask. As of Aug. 22, 2025, this behavior is triggered regardless of whether you set `tool_choice: "auto"` or `tool_choice: "none"`. Enforcing not choosing that tool via prompting also doesn't work.
+
 ---
 
 ## Token Counting & Truncation

{symbolicai-0.17.5 → symbolicai-0.18.0}/symai/__init__.py

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

{symbolicai-0.17.5 → symbolicai-0.18.0}/symai/backend/engines/neurosymbolic/__init__.py

@@ -1,11 +1,13 @@
 from ...mixin import (ANTHROPIC_CHAT_MODELS, ANTHROPIC_REASONING_MODELS,
                       DEEPSEEK_CHAT_MODELS, DEEPSEEK_REASONING_MODELS,
                       GOOGLE_CHAT_MODELS, GOOGLE_REASONING_MODELS,
+                      GROQ_CHAT_MODELS, GROQ_REASONING_MODELS,
                       OPENAI_CHAT_MODELS, OPENAI_REASONING_MODELS)
 from .engine_anthropic_claudeX_chat import ClaudeXChatEngine
 from .engine_anthropic_claudeX_reasoning import ClaudeXReasoningEngine
 from .engine_deepseekX_reasoning import DeepSeekXReasoningEngine
 from .engine_google_geminiX_reasoning import GeminiXReasoningEngine
+from .engine_groq import GroqEngine
 from .engine_openai_gptX_chat import GPTXChatEngine
 from .engine_openai_gptX_reasoning import GPTXReasoningEngine
 
@@ -17,4 +19,6 @@ ENGINE_MAPPING = {
     **{model_name: GeminiXReasoningEngine for model_name in GOOGLE_REASONING_MODELS},
     **{model_name: GPTXChatEngine for model_name in OPENAI_CHAT_MODELS},
     **{model_name: GPTXReasoningEngine for model_name in OPENAI_REASONING_MODELS},
+    **{model_name: GroqEngine for model_name in GROQ_CHAT_MODELS},
+    **{model_name: GroqEngine for model_name in GROQ_REASONING_MODELS},
 }

{symbolicai-0.17.5 → symbolicai-0.18.0}/symai/backend/engines/neurosymbolic/engine_groq.py

@@ -29,7 +29,7 @@ class GroqEngine(Engine):
         if self.id() != 'neurosymbolic':
             return # do not initialize if not neurosymbolic; avoids conflict with llama.cpp check in EngineRepository.register_from_package
         openai.api_key = self.config['NEUROSYMBOLIC_ENGINE_API_KEY']
-        self.model = self.config['NEUROSYMBOLIC_ENGINE_MODEL'].replace('groq:', '')
+        self.model = self.config['NEUROSYMBOLIC_ENGINE_MODEL'] # Keep the original config name to avoid confusion in downstream tasks
         self.seed = None
         self.name = self.__class__.__name__
 
@@ -49,7 +49,7 @@ class GroqEngine(Engine):
         if 'NEUROSYMBOLIC_ENGINE_API_KEY' in kwargs:
             openai.api_key = kwargs['NEUROSYMBOLIC_ENGINE_API_KEY']
         if 'NEUROSYMBOLIC_ENGINE_MODEL' in kwargs:
-            self.model = kwargs['NEUROSYMBOLIC_ENGINE_MODEL'].replace('groq:', '')
+            self.model = kwargs['NEUROSYMBOLIC_ENGINE_MODEL']
         if 'seed' in kwargs:
             self.seed = kwargs['seed']
 
@@ -59,18 +59,9 @@ class GroqEngine(Engine):
     def compute_remaining_tokens(self, prompts: list) -> int:
         raise NotImplementedError("Token counting not implemented for this engine.")
 
-    def _handle_image_content(self, content: str) -> list:
-        """Handle image content by processing vision patterns and returning image file data."""
-        def extract_pattern(text):
-            pattern = r'<<vision:(.*?):>>'
-            return re.findall(pattern, text)
-        raise NotImplementedError("Image content handling not implemented for this engine.")
-
-
-    def _remove_vision_pattern(self, text: str) -> str:
-        """Remove vision patterns from text."""
-        pattern = r'<<vision:(.*?):>>'
-        return re.sub(pattern, '', text)
+    def _handle_prefix(self, model_name: str) -> str:
+        """Handle prefix for model name."""
+        return model_name.replace('groq:', '')
 
     def _extract_thinking_content(self, output: list[str]) -> tuple[str | None, list[str]]:
         """Extract thinking content from model output if present and return cleaned output."""
@@ -115,7 +106,7 @@ class GroqEngine(Engine):
                 openai.api_key = self.config['NEUROSYMBOLIC_ENGINE_API_KEY']
 
             callback = self.client.chat.completions.create
-            kwargs['model'] = kwargs['model'] if 'model' in kwargs else self.model
+            kwargs['model'] = self._handle_prefix(kwargs['model']) if 'model' in kwargs else self._handle_prefix(self.model)
 
             if except_remedy is not None:
                 res = except_remedy(self, e, callback, argument)
@@ -160,12 +151,6 @@ class GroqEngine(Engine):
         if argument.prop.response_format:
             _rsp_fmt = argument.prop.response_format
             assert _rsp_fmt.get('type') is not None, 'Expected format `{ "type": "json_object" }`! We are using the OpenAI compatible API for Groq. See more here: https://console.groq.com/docs/tool-use'
-            if _rsp_fmt["type"] == "json_object":
-                # OpenAI docs:
-                    # "Important: when using JSON mode, you must also instruct the model
-                    #  to produce JSON yourself via a system or user message"
-                    #  Assuming this stays true even for this engine
-                system += f'<RESPONSE_FORMAT/>\nYou are a helpful assistant designed to output JSON.\n\n'
 
         ref = argument.prop.instance
         static_ctxt, dyn_ctxt = ref.global_context
@@ -256,11 +241,11 @@ class GroqEngine(Engine):
 
         payload = {
             "messages": messages,
-            "model": kwargs.get('model', self.model),
+            "model": self._handle_prefix(kwargs.get('model', self.model)),
             "seed": kwargs.get('seed', self.seed),
             "max_completion_tokens": kwargs.get('max_completion_tokens'),
             "stop": kwargs.get('stop'),
-            "temperature": kwargs.get('temperature', 0.6), # Default temperature for Kimi K2 (https://huggingface.co/moonshotai/Kimi-K2-Instruct)
+            "temperature": kwargs.get('temperature', 1), # Default temperature for gpt-oss-120b
             "frequency_penalty": kwargs.get('frequency_penalty', 0),
             "presence_penalty": kwargs.get('presence_penalty', 0),
             "reasoning_effort": kwargs.get('reasoning_effort'), # Field available only for qwen3 models
@@ -268,11 +253,11 @@ class GroqEngine(Engine):
             "top_p": kwargs.get('top_p', 1),
             "n": n,
             "tools": kwargs.get('tools'),
-            "tool_choice": kwargs.get('tool_choice', 'none'),
+            "tool_choice": kwargs.get('tool_choice', 'auto' if kwargs.get('tools') else 'none'),
             "response_format": kwargs.get('response_format'),
         }
 
-        if not self.model.startswith('qwen'):
+        if not self._handle_prefix(self.model).startswith('qwen'):
             del payload['reasoning_effort']
 
         return payload

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

@@ -0,0 +1,304 @@
+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: int
+    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, starts_ends = self._insert_citation_markers(text, annotations)
+            self._value = replaced_text
+            self._citations = [
+                Citation(id=cid, title=title, url=url, start=starts_ends[cid][0], end=starts_ends[cid][1])
+                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:
+        if isinstance(value.get('output_text'), str) and value.get('output_text'):
+            return value.get('output_text')
+        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):
+        segments = []
+        global_annotations = []
+        pos = 0
+        for output in value.get('output', []) or []:
+            if output.get('type') != 'message' or not output.get('content'):
+                continue
+            for content in output.get('content', []) or []:
+                seg_text = content.get('text') or ''
+                if not isinstance(seg_text, str):
+                    continue
+                for ann in (content.get('annotations') or []):
+                    if ann.get('type') == 'url_citation' and ann.get('url'):
+                        start = ann.get('start_index', 0)
+                        end = ann.get('end_index', 0)
+                        global_annotations.append({
+                            'type': 'url_citation',
+                            'url': ann.get('url'),
+                            'title': (ann.get('title') or '').strip(),
+                            'start_index': pos + int(start),
+                            'end_index': pos + int(end),
+                        })
+                segments.append(seg_text)
+                pos += len(seg_text)
+
+        built_text = ''.join(segments) if segments else None
+        # Prefer top-level output_text if present AND segments are empty (no way to compute indices)
+        if not built_text and isinstance(value.get('output_text'), str):
+            return value.get('output_text'), []
+        return built_text, global_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 _insert_citation_markers(self, text: str, annotations):
+        title_map = self._make_title_map(annotations)
+        id_map: dict[str, int] = {}
+        first_span: dict[int, tuple[int, int]] = {}
+        ordered: list[tuple[int, str, str]] = []  # (id, title, normalized_url)
+        next_id = 1
+
+        url_anns = [a for a in annotations or [] if a.get('type') == 'url_citation' and a.get('url')]
+        url_anns.sort(key=lambda a: int(a.get('start_index', 0)))
+
+        pieces: list[str] = []
+        cursor = 0
+        out_len = 0  # length of output built so far (after cleaning and prior markers)
+
+        def _get_id(nu: str) -> int:
+            nonlocal next_id
+            if nu not in id_map:
+                cid = next_id
+                id_map[nu] = cid
+                title = title_map.get(nu) or self._hostname(nu)
+                ordered.append((cid, title, nu))
+                next_id += 1
+            return id_map[nu]
+
+        for ann in url_anns:
+            start = int(ann.get('start_index', 0))
+            end = int(ann.get('end_index', 0))
+            if end <= cursor:
+                continue  # skip overlapping or backwards spans
+            url = ann.get('url')
+            nu = self._normalize_url(url)
+            cid = _get_id(nu)
+            title = title_map.get(nu) or self._hostname(nu)
+
+            prefix = text[cursor:start]
+            prefix_clean = self._strip_markdown_links(prefix)
+            pieces.append(prefix_clean)
+            out_len += len(prefix_clean)
+
+            span_text = text[start:end]
+            span_clean = self._strip_markdown_links(span_text)
+            span_end_out = out_len + len(span_clean)
+            pieces.append(span_clean)
+            out_len = span_end_out
+
+            marker = f"[{cid}] ({title})\n"
+            marker_start_out = out_len
+            marker_end_out = out_len + len(marker)
+            if cid not in first_span:
+                first_span[cid] = (marker_start_out, marker_end_out)
+            pieces.append(marker)
+            out_len = marker_end_out
+            cursor = end
+
+        tail_clean = self._strip_markdown_links(text[cursor:])
+        pieces.append(tail_clean)
+        replaced = ''.join(pieces)
+
+        starts_ends = {cid: first_span.get(cid, (0, 0)) for cid, _, _ in ordered}
+        return replaced, ordered, starts_ends
+
+    def _strip_markdown_links(self, text: str) -> str:
+        # Remove ([text](http...)) including surrounding parentheses
+        pattern_paren = re.compile(r"\(\s*\[[^\]]+\]\(https?://[^)]+\)\s*\)")
+        text = pattern_paren.sub('', text)
+        # Remove bare [text](http...)
+        pattern_bare = re.compile(r"\[[^\]]+\]\(https?://[^)]+\)")
+        text = pattern_bare.sub('', text)
+        # Remove parentheses that became empty or contain only commas/whitespace like (, , )
+        pattern_empty_paren = re.compile(r"\(\s*\)")
+        text = pattern_empty_paren.sub('', text)
+        pattern_commas_only = re.compile(r"\(\s*(,\s*)+\)")
+        text = pattern_commas_only.sub('', text)
+        # Collapse potential double spaces resulting from removals
+        return re.sub(r"\s{2,}", " ", text).strip()
+
+    def __str__(self) -> str:
+        if isinstance(self._value, str) and self._value:
+            return self._value
+        try:
+            return json.dumps(self.raw, indent=2)
+        except TypeError:
+            return str(self.raw)
+
+    def _repr_html_(self) -> str:
+        if isinstance(self._value, str) and self._value:
+            return f"<pre>{self._value}</pre>"
+        try:
+            return f"<pre>{json.dumps(self.raw, indent=2)}</pre>"
+        except Exception:
+            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.5 → symbolicai-0.18.0}/symai/backend/mixin/__init__.py

@@ -4,5 +4,7 @@ from .deepseek import SUPPORTED_CHAT_MODELS as DEEPSEEK_CHAT_MODELS
 from .deepseek import SUPPORTED_REASONING_MODELS as DEEPSEEK_REASONING_MODELS
 from .google import SUPPORTED_CHAT_MODELS as GOOGLE_CHAT_MODELS
 from .google import SUPPORTED_REASONING_MODELS as GOOGLE_REASONING_MODELS
+from .groq import SUPPORTED_CHAT_MODELS as GROQ_CHAT_MODELS
+from .groq import SUPPORTED_REASONING_MODELS as GROQ_REASONING_MODELS
 from .openai import SUPPORTED_CHAT_MODELS as OPENAI_CHAT_MODELS
 from .openai import SUPPORTED_REASONING_MODELS as OPENAI_REASONING_MODELS

symbolicai-0.18.0/symai/backend/mixin/groq.py

@@ -0,0 +1,10 @@
+SUPPORTED_CHAT_MODELS = [
+    "groq:moonshotai/kimi-k2-instruct"
+]
+
+SUPPORTED_REASONING_MODELS = [
+    "groq:openai/gpt-oss-120b",
+    "groq:openai/gpt-oss-20b",
+    "groq:qwen/qwen3-32b",
+    "groq:deepseek-r1-distill-llama-70b"
+]

{symbolicai-0.17.5 → symbolicai-0.18.0}/symai/components.py

@@ -1147,8 +1147,17 @@ class MetadataTracker(Expression):
         # Note on try/except:
         # The unpacking shouldn't fail; if it fails, it's likely the API response format has changed and we need to know that ASAP
         for (_, engine_name, model_name), metadata in self._metadata.items():
-            if engine_name in ("GPTXChatEngine", "GPTXReasoningEngine"):
-                try:
+            try:
+                if engine_name == "GroqEngine":
+                    usage = metadata["raw_output"].usage
+                    token_details[(engine_name, model_name)]["usage"]["completion_tokens"] += usage.completion_tokens
+                    token_details[(engine_name, model_name)]["usage"]["prompt_tokens"] += usage.prompt_tokens
+                    token_details[(engine_name, model_name)]["usage"]["total_tokens"] += usage.total_tokens
+                    token_details[(engine_name, model_name)]["usage"]["total_calls"] += 1
+                    #!: Backward compatibility for components like `RuntimeInfo`
+                    token_details[(engine_name, model_name)]["prompt_breakdown"]["cached_tokens"] += 0 # Assignment not allowed with defualtdict
+                    token_details[(engine_name, model_name)]["completion_breakdown"]["reasoning_tokens"] += 0
+                elif engine_name in ("GPTXChatEngine", "GPTXReasoningEngine"):
                     usage = metadata["raw_output"].usage
                     token_details[(engine_name, model_name)]["usage"]["completion_tokens"] += usage.completion_tokens
                     token_details[(engine_name, model_name)]["usage"]["prompt_tokens"] += usage.prompt_tokens
@@ -1160,10 +1169,7 @@ class MetadataTracker(Expression):
                     token_details[(engine_name, model_name)]["completion_breakdown"]["reasoning_tokens"] += usage.completion_tokens_details.reasoning_tokens
                     token_details[(engine_name, model_name)]["prompt_breakdown"]["audio_tokens"] += usage.prompt_tokens_details.audio_tokens
                     token_details[(engine_name, model_name)]["prompt_breakdown"]["cached_tokens"] += usage.prompt_tokens_details.cached_tokens
-                except Exception as e:
-                    CustomUserWarning(f"Failed to parse metadata for {engine_name}: {e}", raise_with=AttributeError)
-            elif engine_name == "GPTXSearchEngine":
-                try:
+                elif engine_name == "GPTXSearchEngine":
                     usage = metadata["raw_output"].usage
                     token_details[(engine_name, model_name)]["usage"]["prompt_tokens"] += usage.input_tokens
                     token_details[(engine_name, model_name)]["usage"]["completion_tokens"] += usage.output_tokens
@@ -1171,11 +1177,11 @@ class MetadataTracker(Expression):
                     token_details[(engine_name, model_name)]["usage"]["total_calls"] += 1
                     token_details[(engine_name, model_name)]["prompt_breakdown"]["cached_tokens"] += usage.input_tokens_details.cached_tokens
                     token_details[(engine_name, model_name)]["completion_breakdown"]["reasoning_tokens"] += usage.output_tokens_details.reasoning_tokens
-                except Exception as e:
-                    CustomUserWarning(f"Failed to parse metadata for {engine_name}: {e}", raise_with=AttributeError)
-            else:
-                logger.warning(f"Tracking {engine_name} is not supported.")
-                continue
+                else:
+                    logger.warning(f"Tracking {engine_name} is not supported.")
+                    continue
+            except Exception as e:
+                CustomUserWarning(f"Failed to parse metadata for {engine_name}: {e}", raise_with=AttributeError)
 
         # Convert to normal dict
         return {**token_details}
@@ -1193,6 +1199,7 @@ class MetadataTracker(Expression):
         # Skipz first entry
         for (_, engine_name), metadata in list(self._metadata.items())[1:]:
             if engine_name not in ("GPTXChatEngine", "GPTXReasoningEngine", "GPTXSearchEngine"):
+                logger.warning(f"Metadata accumulation for {engine_name} is not supported. Try `.usage` instead for now.")
                 continue
 
             # Accumulate time if it exists

{symbolicai-0.17.5 → symbolicai-0.18.0}/symai/misc/console.py

@@ -2,6 +2,7 @@ import re
 import pygments
 import logging
 
+#@TODO: refactor to use rich instead of prompt_toolkit
 from html import escape as escape_html
 from pygments.lexers.python import PythonLexer
 from pygments.lexers.javascript import JavascriptLexer
@@ -49,8 +50,8 @@ class ConsoleStyle(object):
         message = str(message)
         if self.logging:
             logger.debug(message)
-        if escape:
-            message = escape_html(message)
+        # Prepare safe content for HTML printing without mutating the original
+        content_for_html = escape_html(message) if escape else message
         style = self.style_types.get(self.style_type, self.style_types['default'])
 
         if style == self.style_types['code']:
@@ -80,7 +81,6 @@ class ConsoleStyle(object):
         elif style == self.style_types['default']:
             print(message)
         elif style == self.style_types['custom']:
-            print(HTML(f'<style fg="{self.color}">{message}</style>'))
+            print(HTML(f'<style fg="{self.color}">{content_for_html}</style>'))
         else:
-            print(HTML(f'<style fg="{style}">{message}</style>'))
-
+            print(HTML(f'<style fg="{style}">{content_for_html}</style>'))

{symbolicai-0.17.5 → symbolicai-0.18.0}/symai/shellsv.py

@@ -13,6 +13,7 @@ import traceback
 from pathlib import Path
 from typing import Iterable, Tuple
 
+#@TODO: refactor to use rich instead of prompt_toolkit
 from prompt_toolkit import HTML, PromptSession, print_formatted_text
 from prompt_toolkit.completion import Completer, Completion, WordCompleter
 from prompt_toolkit.history import History

{symbolicai-0.17.5 → symbolicai-0.18.0}/symai/utils.py

@@ -224,9 +224,7 @@ class RuntimeInfo:
             try:
                 return RuntimeInfo.from_usage_stats(tracker.usage, total_elapsed_time)
             except Exception as e:
-                raise e
-                CustomUserWarning(f"Failed to parse metadata; returning empty RuntimeInfo: {e}")
-                return RuntimeInfo(0, 0, 0, 0, 0, 0, 0, 0)
+                CustomUserWarning(f"Failed to parse metadata: {e}", raise_with=ValueError)
         return RuntimeInfo(0, 0, 0, 0, 0, 0, 0, 0)
 
     @staticmethod
@@ -234,12 +232,13 @@ class RuntimeInfo:
         if usage_stats is not None:
             usage_per_engine = {}
             for (engine_name, model_name), data in usage_stats.items():
+                #!: This object interacts with `MetadataTracker`; its fields are mandatory and handled there
                 data = Box(data)
                 usage_per_engine[(engine_name, model_name)] = RuntimeInfo(
                     total_elapsed_time=total_elapsed_time,
                     prompt_tokens=data.usage.prompt_tokens,
                     completion_tokens=data.usage.completion_tokens,
-                    reasoning_tokens=getattr(data.usage, 'reasoning_tokens', 0),
+                    reasoning_tokens=data.completion_breakdown.reasoning_tokens,
                     cached_tokens=data.prompt_breakdown.cached_tokens,
                     total_calls=data.usage.total_calls,
                     total_tokens=data.usage.total_tokens,

{symbolicai-0.17.5 → symbolicai-0.18.0}/symbolicai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symbolicai
-Version: 0.17.5
+Version: 0.18.0
 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.5 → symbolicai-0.18.0}/symbolicai.egg-info/SOURCES.txt

@@ -167,6 +167,7 @@ symai/backend/mixin/__init__.py
 symai/backend/mixin/anthropic.py
 symai/backend/mixin/deepseek.py
 symai/backend/mixin/google.py
+symai/backend/mixin/groq.py
 symai/backend/mixin/openai.py
 symai/collect/__init__.py
 symai/collect/dynamic.py