symbolicai 0.17.5__py3-none-any.whl → 0.18.0__py3-none-any.whl

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
 

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},
 }

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

symai/backend/engines/search/engine_openai.py

@@ -1,14 +1,18 @@
+import hashlib
 import json
 import logging
-import requests
+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 ...settings import SYMAI_CONFIG
 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)
@@ -16,9 +20,13 @@ 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
+    id: int
     title: str
     url: str
     start: int
@@ -34,42 +42,187 @@ class SearchResult(Result):
         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
+            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 as e:
+        except Exception:
             return f"<pre>{str(self.raw)}</pre>"
 
     def get_citations(self) -> list[Citation]:
@@ -86,6 +239,10 @@ class GPTXSearchEngine(Engine):
         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 \
@@ -117,19 +274,12 @@ class GPTXSearchEngine(Engine):
             "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
+            "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
         }
-        api_url = "https://api.openai.com/v1/responses"
 
         try:
-            res = requests.post(api_url, json=payload, headers=headers)
-            res = SearchResult(res.json())
+            res = self.client.responses.create(**payload)
+            res = SearchResult(res.dict())
         except Exception as e:
             CustomUserWarning(f"Failed to make request: {e}", raise_with=ValueError)
 

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

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"
+]

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

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>'))

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

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.dist-info → symbolicai-0.18.0.dist-info}/METADATA

@@ -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.dist-info → symbolicai-0.18.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 symai/TERMS_OF_SERVICE.md,sha256=HN42UXVI_wAVDHjMShzy_k7xAsbjXaATNeMKcIte_eg,91409
-symai/__init__.py,sha256=q4Lept252Iy6bETSCL9-LMHKU9NrPT8qJMSbsWwdwVQ,16464
+symai/__init__.py,sha256=xXbdl7oTmx1KKaCLI3R4_2oktrKmNTy1ommzZ5ZsW34,16464
 symai/chat.py,sha256=vqEe7NqSWdzr9ixkko_094SR1LIbgPLcZxQ8W7782N4,12775
-symai/components.py,sha256=L_Kbuyc0JW6c8zkVRd406HzPifLM3ZytRVas6EHE7Ls,50617
+symai/components.py,sha256=YazuyQasU7P3dvUHn-h5A54D-lf6wD_Hqc8Y6Gnd11g,51440
 symai/constraints.py,sha256=S1ywLB8nFQy4-beDoJz6IvLTiZHGR8Fu5RNTY4v5zG0,1641
 symai/core.py,sha256=1g45AjJ5wkz1cNTbtoDbd8QlOUc-v-3sWNmDTxaeqY0,69041
 symai/core_ext.py,sha256=binru2AjB8K-arbNLiu1wnNodtFxgqk26b-iLVhPoSU,9322
@@ -15,11 +15,11 @@ symai/pre_processors.py,sha256=08C1FfjwI5bhxk8Xt6aB5wPizB5o3DEFkTh4S8PkS5Q,16886
 symai/processor.py,sha256=ZV6uQwybUhCJCTdvBwVxMmleuX0EUVOQHZSvsm5F8pw,1586
 symai/prompts.py,sha256=OZWW4_S6yf2mpwuiHWlcZz82ITKkYEq4-DIzBHalJnI,89831
 symai/shell.py,sha256=fzWvnEovQartpO3UhjLcH9TcydgxXzf3YyfuLlU_GDI,6237
-symai/shellsv.py,sha256=wjnzAfQBGpq4YSPMPpjfsliEBwePID-DFpPzw6txb-o,37222
+symai/shellsv.py,sha256=Y552dkQrKrnMhwDyK9wJSA1bnJF_bh60iMBom-eAbsM,37277
 symai/strategy.py,sha256=D2DD5mTgp2aDzIXNdKU1FwoSdnIWcKYL2Yv7Tue-Sy8,37885
 symai/symbol.py,sha256=unRyZj_2KepkV6xTLYLWzYUkBZh2J5UB-OHyPhFn7uE,40637
 symai/symsh.md,sha256=QwY_-fX0Ge7Aazul0xde2DuF2FZLw_elxrkXR3kuKDQ,1245
-symai/utils.py,sha256=Dou69Lo5JE0pij3KmAzGMnV4T5L4YVTlRV5I8uSREB8,9793
+symai/utils.py,sha256=chZwVcjHnDizYFlmdK6MMPAa7W40kqpya9zctAwtYTI,9813
 symai/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 symai/backend/base.py,sha256=7zXaZtByUXfOqxqEvbdmB_E0GYvvpwfj3FPsf3EZP0Y,7523
 symai/backend/settings.py,sha256=YCt0AJgWM2egRg3hLz4S1vEypVHm654oXxgzNvLSLj8,3213
@@ -42,12 +42,12 @@ symai/backend/engines/imagecaptioning/engine_llavacpp_client.py,sha256=ZbW6sxFE9
 symai/backend/engines/index/engine_pinecone.py,sha256=Horf9lzw2QLMdYvvBLeAu3MOyiTbNo30en28Ifm4AVA,8956
 symai/backend/engines/index/engine_vectordb.py,sha256=q0jUvmAh1AEPIE5fpayjSmSg-U9W1OffDXkx4tkFvNI,8048
 symai/backend/engines/lean/engine_lean4.py,sha256=1ZZOzw1kDAJH6hMCyDtK50LAYSsoU8pApWVPI_9Eul0,9440
-symai/backend/engines/neurosymbolic/__init__.py,sha256=T1GWAeGlQDpeEJsaMt_7bCbRA_UsZ3j3_rn0AaxVmNc,1200
+symai/backend/engines/neurosymbolic/__init__.py,sha256=mZpsX-UVc86nYjn1hxyJM1AvVq5BvZK8sr5PU-QgwVU,1438
 symai/backend/engines/neurosymbolic/engine_anthropic_claudeX_chat.py,sha256=01BdmObww3NzbYfb8OscLnwrxoPW48JkLWQOFeopURM,18728
 symai/backend/engines/neurosymbolic/engine_anthropic_claudeX_reasoning.py,sha256=ZPSksJjm3dnJBZKFDFp9HJpD5Nd2F2HxIwoZzo1Ders,19772
 symai/backend/engines/neurosymbolic/engine_deepseekX_reasoning.py,sha256=ZaZvAVpgv5GYjE2yZmYhP5zUnEKak5I1mndRfiGfr6U,8995
 symai/backend/engines/neurosymbolic/engine_google_geminiX_reasoning.py,sha256=kxGWYsxnQkpsm40HB1MUGggWmrWz8avCY3jvNrohaKw,25622
-symai/backend/engines/neurosymbolic/engine_groq.py,sha256=yYt4wGCSAh5W_FySTQprzbzv8OKu5cCezhptwReNAN0,12485
+symai/backend/engines/neurosymbolic/engine_groq.py,sha256=g_Xnl8UezHF2dksFc4MYw3DCQqh8nQFUhVIkGCXegtc,11748
 symai/backend/engines/neurosymbolic/engine_huggingface.py,sha256=XIu9BnQo-J2flXFCCKwCJJmVozU9WDNkPndmpi-DlzE,7920
 symai/backend/engines/neurosymbolic/engine_llama_cpp.py,sha256=ZbHaRYOb7QSD0OrFURp4PT0KJgQk3gdJMD_Itxn7QcU,11323
 symai/backend/engines/neurosymbolic/engine_openai_gptX_chat.py,sha256=Y-auxUFC4W9dfRzzgI3_rbWbPiOx4xfvKS4sM0KxP40,25250
@@ -55,7 +55,7 @@ symai/backend/engines/neurosymbolic/engine_openai_gptX_completion.py,sha256=YgxR
 symai/backend/engines/neurosymbolic/engine_openai_gptX_reasoning.py,sha256=QVbyZybUPSAQHiA66V6we2W2dAsk52g1kJ7kMdGqb9I,22951
 symai/backend/engines/ocr/engine_apilayer.py,sha256=hZo4lk0ECRIzaGEpmCSNjR5Xrh8mwkKMD2ddpdgioVU,2399
 symai/backend/engines/output/engine_stdout.py,sha256=2hhyhMHFJTfjVRaODYd_5XPnV9pT03URcpYbeMY_USU,951
-symai/backend/engines/search/engine_openai.py,sha256=4q71QMsYUOw--2dz5gE-uu6TewO6fDd-KF5tz9PZnaQ,5779
+symai/backend/engines/search/engine_openai.py,sha256=QeWCu5ofJFZwIWSolIYAlVN1KjFngM8GpSUhxPP4bps,11688
 symai/backend/engines/search/engine_perplexity.py,sha256=yxuhGaA38d1FRbLv6piLll0QDxCCyBVK6eeomjYNryM,4157
 symai/backend/engines/search/engine_serpapi.py,sha256=UqvGHs1J9BOv05C0FJUQjbz29_VuWncIkeDwlRPUilU,3698
 symai/backend/engines/speech_to_text/engine_local_whisper.py,sha256=LRsXliCpHDFPFaE-vPky3-DLkmYwmwe2mxfF0Brz4Wg,8220
@@ -64,10 +64,11 @@ symai/backend/engines/text_to_speech/engine_openai.py,sha256=rq34pTr4bRU-HeA84Av
 symai/backend/engines/text_vision/engine_clip.py,sha256=EUwlom2e7m_efCK2zuPbe1TzyT9CPRlY0mkFTCmXp0U,3740
 symai/backend/engines/userinput/engine_console.py,sha256=FwOakooxCc4oaQv6nYd-uIG2SxJRUI3n64cIs3B82FY,770
 symai/backend/engines/webscraping/engine_requests.py,sha256=qsEAiEZJWLFXqhFfBCsQbSvFWgjA-rXDKMxu8Ezdl_8,4914
-symai/backend/mixin/__init__.py,sha256=94dj1x1WBPRmcuguFd7rSrPyja_wEZJeq1nwaRXEzXc,572
+symai/backend/mixin/__init__.py,sha256=ischewsMtIFanU30N32ac2Eb8u4hjWxuEb6mrniUv6Y,702
 symai/backend/mixin/anthropic.py,sha256=k_7gTvbKrucMW54MR7q8S9RbaQ39AaV2uvgil5F-dnM,1936
 symai/backend/mixin/deepseek.py,sha256=U-xtUjR9dFTkmiJPAF5_tyuTxpnUxv5gki9WjTfrVL4,379
 symai/backend/mixin/google.py,sha256=aCQDxo_F0_mQGb8h2iYhQmOlo7NuF2IhY85CYro-m4k,453
+symai/backend/mixin/groq.py,sha256=ZXbJcAMR6mHiA5FfnpWivb0l71cgNR-5pYRtWNe8Nmc,232
 symai/backend/mixin/openai.py,sha256=ZzteR8wIJoo4sLtNtea-Bb1IAGD0WLJ3cqGG5GGAJN4,4638
 symai/collect/__init__.py,sha256=eaLjpARuQCa_ChZjyogYoh-w9-xXuNxRAFND2liLvZk,104
 symai/collect/dynamic.py,sha256=3VDMZ-EJKE-GsqhyuPrwbfoLD9LFec1QfuVr7nOKMfE,3928
@@ -141,7 +142,7 @@ symai/formatter/regex.py,sha256=POf4anhw2FovCQinq3yFWGNcWXf3diIV8yVrp9adieA,9924
 symai/menu/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 symai/menu/screen.py,sha256=YmCfKEt76GGv4aQ1ikeC3C7xEw5HJn18jhfZuYAoaCs,1758
 symai/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-symai/misc/console.py,sha256=bo8uTI0RpjUPARwVXaVrcbbm1RbmUU2cBkYnZmHiTwY,2892
+symai/misc/console.py,sha256=hwAET_vwX7bwxmrQ6lgUbZhv3ME5_4vMtOWeCAHg5no,3052
 symai/misc/loader.py,sha256=7lyIMIvU6Ywo_xt-TM8Xqhc6W4tY67U5XzxSkuAYZi8,1635
 symai/models/__init__.py,sha256=QCYmMOhHk3t6HhTApBMxIeS3dX4_bKfHNr6a9LzRa8s,163
 symai/models/base.py,sha256=lnkcCwJfv_Yg5kiLRazbVq9jIRKhNR75W8_S9NBVmMo,40881
@@ -152,8 +153,8 @@ symai/ops/primitives.py,sha256=EaB2Ekx9yGNDaQa3aKS5KpuEr5awAUbO3OcBbufI-l4,11072
 symai/server/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 symai/server/huggingface_server.py,sha256=UpSBflnQaenDjY1AAn5LUYeg5J4gJLWiMuC5DcoIV3E,8743
 symai/server/llama_cpp_server.py,sha256=qVCldTdcQhK2YCu7sDNSYziu1p2AQieqMFfY028-yOc,2049
-symbolicai-0.17.5.dist-info/METADATA,sha256=GcuEpuspOaef3uCFQ6ZQ63fyOwP9V0-he1v1AYYEV08,21327
-symbolicai-0.17.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-symbolicai-0.17.5.dist-info/entry_points.txt,sha256=JV5sdydIfUZdDF6QBEQHiZHod6XNPjCjpWQrXh7gTAw,261
-symbolicai-0.17.5.dist-info/top_level.txt,sha256=bOoIDfpDIvCQtQgXcwVKJvxAKwsxpxo2IL4z92rNJjw,6
-symbolicai-0.17.5.dist-info/RECORD,,
+symbolicai-0.18.0.dist-info/METADATA,sha256=EpPFn8hwc36E-UwtnlQlnAX8qR4Te-rqxfBemyTfiK8,21327
+symbolicai-0.18.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+symbolicai-0.18.0.dist-info/entry_points.txt,sha256=JV5sdydIfUZdDF6QBEQHiZHod6XNPjCjpWQrXh7gTAw,261
+symbolicai-0.18.0.dist-info/top_level.txt,sha256=bOoIDfpDIvCQtQgXcwVKJvxAKwsxpxo2IL4z92rNJjw,6
+symbolicai-0.18.0.dist-info/RECORD,,