symbolicai 0.17.6__tar.gz → 0.18.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symbolicai
-Version: 0.17.6
+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.6 → 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.6 → 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.6"
+SYMAI_VERSION = "0.18.0"
 __version__   = SYMAI_VERSION
 __root_dir__  = config_manager.config_dir
 

{symbolicai-0.17.6 → 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.6 → 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.17.6 → symbolicai-0.18.0}/symai/backend/engines/search/engine_openai.py

@@ -26,7 +26,7 @@ TRACKING_KEYS = {
 
 @dataclass
 class Citation:
-    id: str
+    id: int
     title: str
     url: str
     start: int
@@ -47,10 +47,10 @@ class SearchResult(Result):
                 self._value = None
                 self._citations = []
                 return
-            replaced_text, ordered = self._replace_links_with_citations(text, annotations, id_mode="sequential")
+            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=0, end=0)
+                Citation(id=cid, title=title, url=url, start=starts_ends[cid][0], end=starts_ends[cid][1])
                 for cid, title, url in ordered
             ]
 
@@ -59,6 +59,8 @@ class SearchResult(Result):
             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'):
@@ -68,19 +70,35 @@ class SearchResult(Result):
         return text
 
     def _extract_text_and_annotations(self, value):
-        text = None
-        annotations = []
-        for output in value.get('output', []):
+        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 []:
-                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
+                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)
@@ -115,48 +133,96 @@ class SearchResult(Result):
     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'):
+    def _insert_citation_markers(self, text: str, annotations):
         title_map = self._make_title_map(annotations)
-        id_map = {}
-        ordered = []  # list of ("[n]", title, normalized_url)
+        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
 
-        pattern = re.compile(r"\[([^\]]*?)\]\((https?://[^\s)]+)\)")
+        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) -> str:
+        def _get_id(nu: str) -> int:
             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))
+                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]
 
-        def _repl(m):
-            link_text, url = m.group(1), m.group(2)
+        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)
-            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
+            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]:

{symbolicai-0.17.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.6 → symbolicai-0.18.0}/symbolicai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symbolicai
-Version: 0.17.6
+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.6 → 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

symbolicai-0.18.0/tests/engines/search/openai_engine.py

@@ -0,0 +1,58 @@
+import os
+import re
+
+import pytest
+
+from symai.backend.engines.search.engine_openai import GPTXSearchEngine
+from symai.backend.settings import SYMAI_CONFIG
+from symai.extended.interfaces.openai_search import openai_search
+from symai.functional import EngineRepository
+
+
+def _get_api_key():
+    return (
+        os.environ.get("OPENAI_API_KEY")
+        or SYMAI_CONFIG.get("SEARCH_ENGINE_API_KEY")
+        or os.environ.get("SEARCH_ENGINE_API_KEY")
+    )
+
+
+@pytest.mark.parametrize("model", ["gpt-4.1-mini", "gpt-5-mini"])
+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)
+
+    # Keep the query stable but realistic to elicit citations
+    query = "President of Romania 2025 inauguration timeline and partner (with citations)"
+    search = openai_search()
+    res = search(query, model=model, search_context_size="medium")
+
+    # 1) No leftover markdown link patterns or empty parentheses artifacts
+    assert not re.search(r"\[[^\]]+\]\(https?://[^)]+\)", res.value)
+    assert "(, , )" not in res.value
+    assert "()" not in res.value
+
+    # 2) Citations exist with integer ids and normalized URLs (no utm_ params)
+    citations = res.get_citations()
+    assert isinstance(citations, list) and len(citations) >= 1
+    seen_ids = set()
+    for c in citations:
+        assert isinstance(c.id, int)
+        assert c.id not in seen_ids
+        seen_ids.add(c.id)
+        assert "utm_" not in c.url
+
+        # Slice should match the marker format; allow small whitespace variance before newline
+        slice_text = res.value[c.start:c.end]
+        assert slice_text.startswith(f"[{c.id}] (")
+        assert slice_text.endswith(")\n")
+        # Optional stronger check including title
+        assert slice_text == f"[{c.id}] ({c.title})\n"
+
+    # 3) Formatting: At least one marker pattern with newline is present
+    assert re.search(r"\[\d+\] \([^)]+\)\n", res.value)