symbolicai 1.1.0__py3-none-any.whl → 1.2.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 = "1.1.0"
+SYMAI_VERSION = "1.2.0"
 __version__ = SYMAI_VERSION
 __root_dir__ = config_manager.config_dir
 

symai/backend/engines/index/engine_qdrant.py

@@ -22,7 +22,9 @@ try:
     from qdrant_client.http.models import (
         Distance,
         Filter,
+        NamedVector,
         PointStruct,
+        Query,
         ScoredPoint,
         VectorParams,
     )
@@ -33,6 +35,8 @@ except ImportError:
     VectorParams = None
     PointStruct = None
     Filter = None
+    Query = None
+    NamedVector = None
     ScoredPoint = None
 
 try:
@@ -322,6 +326,50 @@ class QdrantIndexEngine(Engine):
             # Reinitialize client to refresh collection list
             self._init_client()
 
+    def _build_query_filter(self, raw_filter: Any) -> Filter | None:
+        """Normalize various filter representations into a Qdrant Filter.
+
+        Supports:
+        - None: returns None
+        - Existing Filter instance: returned as-is
+        - Dict[str, Any]: converted to equality-based Filter over payload keys
+
+        The dict form is intentionally simple and maps directly to `payload.<key>`
+        equality conditions, which covers the majority of RAG use cases while
+        remaining easy to serialize and pass through higher-level APIs.
+        """
+        if raw_filter is None or Filter is None:
+            return None
+
+        # Already a Filter instance → use directly
+        if isinstance(raw_filter, Filter):
+            return raw_filter
+
+        # Simple dict → build equality-based must filter
+        if isinstance(raw_filter, dict):
+            if models is None:
+                UserMessage(
+                    "Qdrant filter models are not available. "
+                    "Please install `qdrant-client` to use filtering.",
+                    raise_with=ImportError,
+                )
+
+            conditions = []
+            for key, value in raw_filter.items():
+                # We keep semantics simple and robust: every entry is treated as an
+                # equality condition on the payload key (logical AND across keys).
+                conditions.append(
+                    models.FieldCondition(
+                        key=key,
+                        match=models.MatchValue(value=value),
+                    )
+                )
+
+            return Filter(must=conditions) if conditions else None
+
+        # Fallback: pass through other representations (e.g. already-built Filter-like)
+        return raw_filter
+
     def _prepare_points_for_upsert(
         self,
         embeddings: list | np.ndarray | Any,
@@ -338,7 +386,7 @@ class QdrantIndexEngine(Engine):
             embeddings = [embeddings]
 
         for i, vec in enumerate(embeddings):
-            point_id = ids[i] if ids and i < len(ids) else i
+            point_id = self._normalize_point_id(ids[i]) if ids and i < len(ids) else i
             payload = payloads[i] if payloads and i < len(payloads) else {}
             points.append(
                 PointStruct(id=point_id, vector=self._normalize_vector(vec), payload=payload)
@@ -349,6 +397,14 @@ class QdrantIndexEngine(Engine):
     def forward(self, argument):
         kwargs = argument.kwargs
         embedding = argument.prop.prepared_input
+        if embedding is None:
+            embedding = getattr(argument.prop, "prompt", None)
+        if embedding is None:
+            msg = (
+                "Qdrant forward() requires an embedding vector. "
+                "Provide it via prepared_input or prompt before calling forward()."
+            )
+            raise ValueError(msg)
         query = argument.prop.ori_query
         operation = argument.prop.operation
         collection_name = argument.prop.index_name if argument.prop.index_name else self.index_name
@@ -369,8 +425,20 @@ class QdrantIndexEngine(Engine):
             # Ensure collection exists - fail fast if it doesn't
             self._ensure_collection_exists(collection_name)
             index_top_k = kwargs.get("index_top_k", self.index_top_k)
-            # Use existing _query method
-            rsp = self._query(collection_name, embedding, index_top_k)
+            # Optional search parameters
+            score_threshold = kwargs.get("score_threshold")
+            # Accept both `query_filter` and `filter` for convenience
+            raw_filter = kwargs.get("query_filter", kwargs.get("filter"))
+            query_filter = self._build_query_filter(raw_filter)
+
+            # Use shared search helper that already handles retries and normalization
+            rsp = self._search_sync(
+                collection_name=collection_name,
+                query_vector=embedding,
+                limit=index_top_k,
+                score_threshold=score_threshold,
+                query_filter=query_filter,
+            )
         elif operation == "add":
             # Create collection if it doesn't exist (only for write operations)
             self._create_collection_sync(collection_name, collection_dims, self.index_metric)
@@ -446,14 +514,19 @@ class QdrantIndexEngine(Engine):
         )
         def _func():
             query_vector_normalized = self._normalize_vector(query_vector)
-            return self.client.search(
+            # For single vector collections, pass vector directly to query parameter
+            # For named vector collections, use Query(near_vector=NamedVector(name="vector_name", vector=...))
+            # query_points API uses query_filter (not filter) for filtering
+            response = self.client.query_points(
                 collection_name=collection_name,
-                query_vector=query_vector_normalized,
+                query=query_vector_normalized,
                 limit=top_k,
                 with_payload=True,
                 with_vectors=self.index_values,
                 **kwargs,
             )
+            # query_points returns QueryResponse with .points attribute, extract it
+            return response.points
 
         return _func()
 
@@ -563,16 +636,67 @@ class QdrantIndexEngine(Engine):
                     for name, vec in vector_config.items()
                 }
             }
-        return {
+        # Qdrant 1.16.1+ compatibility: vectors_count and indexed_vectors_count may not exist
+        # Use points_count as the primary count, and try to get vectors_count if available
+        result = {
             "name": collection_name,
-            "vectors_count": collection_info.vectors_count,
-            "indexed_vectors_count": collection_info.indexed_vectors_count,
             "points_count": collection_info.points_count,
             "config": {"params": {"vectors": vectors_info}},
         }
 
+        # Try to get vectors_count if available (for older Qdrant versions)
+        if hasattr(collection_info, "vectors_count"):
+            result["vectors_count"] = collection_info.vectors_count
+        else:
+            # In Qdrant 1.16.1+, vectors_count is not available, use points_count as approximation
+            result["vectors_count"] = collection_info.points_count
+
+        # Try to get indexed_vectors_count if available
+        if hasattr(collection_info, "indexed_vectors_count"):
+            result["indexed_vectors_count"] = collection_info.indexed_vectors_count
+        else:
+            # In Qdrant 1.16.1+, indexed_vectors_count may not be available
+            result["indexed_vectors_count"] = collection_info.points_count
+
+        return result
+
     # ==================== Point Operations ====================
 
+    def _normalize_point_id(self, point_id: Any) -> int | uuid.UUID:
+        """Normalize point ID to integer or UUID for Qdrant 1.16.1+ compatibility.
+
+        Qdrant 1.16.1+ requires point IDs to be either unsigned integers or UUIDs.
+        This function converts string IDs (like 'vec-1') to integers or UUIDs.
+        """
+        # If already int or UUID, return as-is
+        if isinstance(point_id, (int, uuid.UUID)):
+            return point_id
+
+        # If string, try to convert
+        if isinstance(point_id, str):
+            # Try to parse as integer first
+            try:
+                # Handle string IDs like "vec-1" by extracting the number
+                if point_id.startswith("vec-"):
+                    num_str = point_id.split("-", 1)[-1]
+                    return int(num_str)
+                # Try direct integer conversion
+                return int(point_id)
+            except (ValueError, AttributeError):
+                # If not a valid integer, try UUID
+                try:
+                    return uuid.UUID(point_id)
+                except (ValueError, AttributeError):
+                    # Fallback: generate UUID from string hash
+                    return uuid.uuid5(uuid.NAMESPACE_DNS, point_id)
+
+        # For other types, try to convert to int
+        try:
+            return int(point_id)
+        except (ValueError, TypeError):
+            # Last resort: generate UUID from string representation
+            return uuid.uuid5(uuid.NAMESPACE_DNS, str(point_id))
+
     def _upsert_points_sync(
         self,
         collection_name: str,
@@ -589,17 +713,17 @@ class QdrantIndexEngine(Engine):
         if isinstance(points[0], dict):
             points = [
                 PointStruct(
-                    id=point["id"],
+                    id=self._normalize_point_id(point["id"]),
                     vector=self._normalize_vector(point["vector"]),
                     payload=point.get("payload", {}),
                 )
                 for point in points
             ]
         else:
-            # Normalize vectors in existing PointStruct objects
+            # Normalize vectors and IDs in existing PointStruct objects
             points = [
                 PointStruct(
-                    id=point.id,
+                    id=self._normalize_point_id(point.id),
                     vector=self._normalize_vector(point.vector),
                     payload=point.payload,
                 )

symai/backend/engines/neurosymbolic/__init__.py

@@ -1,6 +1,8 @@
 from ...mixin import (
     ANTHROPIC_CHAT_MODELS,
     ANTHROPIC_REASONING_MODELS,
+    CEREBRAS_CHAT_MODELS,
+    CEREBRAS_REASONING_MODELS,
     DEEPSEEK_CHAT_MODELS,
     DEEPSEEK_REASONING_MODELS,
     GOOGLE_CHAT_MODELS,
@@ -9,23 +11,29 @@ from ...mixin import (
     GROQ_REASONING_MODELS,
     OPENAI_CHAT_MODELS,
     OPENAI_REASONING_MODELS,
+    OPENAI_RESPONSES_MODELS,
 )
 from .engine_anthropic_claudeX_chat import ClaudeXChatEngine
 from .engine_anthropic_claudeX_reasoning import ClaudeXReasoningEngine
+from .engine_cerebras import CerebrasEngine
 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
+from .engine_openai_responses import OpenAIResponsesEngine
 
 # create the mapping
 ENGINE_MAPPING = {
     **dict.fromkeys(ANTHROPIC_CHAT_MODELS, ClaudeXChatEngine),
     **dict.fromkeys(ANTHROPIC_REASONING_MODELS, ClaudeXReasoningEngine),
+    **dict.fromkeys(CEREBRAS_CHAT_MODELS, CerebrasEngine),
+    **dict.fromkeys(CEREBRAS_REASONING_MODELS, CerebrasEngine),
     **dict.fromkeys(DEEPSEEK_REASONING_MODELS, DeepSeekXReasoningEngine),
     **dict.fromkeys(GOOGLE_REASONING_MODELS, GeminiXReasoningEngine),
     **dict.fromkeys(OPENAI_CHAT_MODELS, GPTXChatEngine),
     **dict.fromkeys(OPENAI_REASONING_MODELS, GPTXReasoningEngine),
+    **dict.fromkeys(OPENAI_RESPONSES_MODELS, OpenAIResponsesEngine),
     **dict.fromkeys(GROQ_CHAT_MODELS, GroqEngine),
     **dict.fromkeys(GROQ_REASONING_MODELS, GroqEngine),
 }
@@ -33,6 +41,8 @@ ENGINE_MAPPING = {
 __all__ = [
     "ANTHROPIC_CHAT_MODELS",
     "ANTHROPIC_REASONING_MODELS",
+    "CEREBRAS_CHAT_MODELS",
+    "CEREBRAS_REASONING_MODELS",
     "DEEPSEEK_CHAT_MODELS",
     "DEEPSEEK_REASONING_MODELS",
     "ENGINE_MAPPING",
@@ -42,6 +52,7 @@ __all__ = [
     "GROQ_REASONING_MODELS",
     "OPENAI_CHAT_MODELS",
     "OPENAI_REASONING_MODELS",
+    "OPENAI_RESPONSES_MODELS",
     "ClaudeXChatEngine",
     "ClaudeXReasoningEngine",
     "DeepSeekXReasoningEngine",
@@ -49,4 +60,5 @@ __all__ = [
     "GPTXReasoningEngine",
     "GeminiXReasoningEngine",
     "GroqEngine",
+    "OpenAIResponsesEngine",
 ]

symai/backend/engines/neurosymbolic/engine_openai_responses.py

@@ -0,0 +1,429 @@
+import json
+import logging
+import re
+from copy import deepcopy
+
+import openai
+import tiktoken
+
+from ....components import SelfPrompt
+from ....utils import UserMessage, encode_media_frames
+from ...base import Engine
+from ...mixin.openai import SUPPORTED_REASONING_MODELS, OpenAIMixin
+from ...settings import SYMAI_CONFIG
+
+logging.getLogger("openai").setLevel(logging.ERROR)
+logging.getLogger("requests").setLevel(logging.ERROR)
+logging.getLogger("urllib").setLevel(logging.ERROR)
+logging.getLogger("httpx").setLevel(logging.ERROR)
+logging.getLogger("httpcore").setLevel(logging.ERROR)
+
+
+_NON_VERBOSE_OUTPUT = (
+    "<META_INSTRUCTION/>\n"
+    "You do not output anything else, like verbose preambles or post explanation, such as "
+    '"Sure, let me...", "Hope that was helpful...", "Yes, I can help you with that...", etc. '
+    "Consider well formatted output, e.g. for sentences use punctuation, spaces etc. or for code use "
+    "indentation, etc. Never add meta instructions information to your output!\n\n"
+)
+
+
+class ResponsesTokenizer:
+    def __init__(self, model: str):
+        self._model = model
+        try:
+            self._tiktoken = tiktoken.encoding_for_model(model)
+        except Exception:
+            self._tiktoken = tiktoken.get_encoding("o200k_base")
+
+    def encode(self, text: str) -> list[int]:
+        return self._tiktoken.encode(text, disallowed_special=())
+
+    def decode(self, tokens: list[int]) -> str:
+        return self._tiktoken.decode(tokens)
+
+
+class OpenAIResponsesEngine(Engine, OpenAIMixin):
+    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["NEUROSYMBOLIC_ENGINE_API_KEY"] = api_key
+            self.config["NEUROSYMBOLIC_ENGINE_MODEL"] = model
+        if self.id() != "neurosymbolic":
+            return
+        openai.api_key = self.config["NEUROSYMBOLIC_ENGINE_API_KEY"]
+        self._prefixed_model = self.config["NEUROSYMBOLIC_ENGINE_MODEL"]
+        self.model = self._strip_prefix(self._prefixed_model)
+        self.seed = None
+        self.name = self.__class__.__name__
+        self.tokenizer = ResponsesTokenizer(model=self.model)
+        self.max_context_tokens = self.api_max_context_tokens()
+        self.max_response_tokens = self.api_max_response_tokens()
+
+        try:
+            self.client = openai.Client(api_key=openai.api_key)
+        except Exception as e:
+            UserMessage(
+                f"Failed to initialize OpenAI client. Caused by: {e}",
+                raise_with=ValueError,
+            )
+
+    def _strip_prefix(self, model_name: str) -> str:
+        return model_name.replace("responses:", "")
+
+    def id(self) -> str:
+        model = self.config.get("NEUROSYMBOLIC_ENGINE_MODEL")
+        if model and model.startswith("responses:"):
+            return "neurosymbolic"
+        return super().id()
+
+    def command(self, *args, **kwargs):
+        super().command(*args, **kwargs)
+        if "NEUROSYMBOLIC_ENGINE_API_KEY" in kwargs:
+            openai.api_key = kwargs["NEUROSYMBOLIC_ENGINE_API_KEY"]
+        if "NEUROSYMBOLIC_ENGINE_MODEL" in kwargs:
+            self._prefixed_model = kwargs["NEUROSYMBOLIC_ENGINE_MODEL"]
+            self.model = self._strip_prefix(self._prefixed_model)
+        if "seed" in kwargs:
+            self.seed = kwargs["seed"]
+
+    def compute_required_tokens(self, messages: list[dict]) -> int:
+        tokens_per_message = 3
+        tokens_per_name = 1
+        num_tokens = 0
+        for message in messages:
+            num_tokens += tokens_per_message
+            for key, value in message.items():
+                if isinstance(value, str):
+                    num_tokens += len(self.tokenizer.encode(value))
+                elif isinstance(value, list):
+                    for v in value:
+                        if isinstance(v, dict) and v.get("type") in ("text", "input_text"):
+                            num_tokens += len(self.tokenizer.encode(v.get("text", "")))
+                if key == "name":
+                    num_tokens += tokens_per_name
+        if self._is_reasoning_model():
+            num_tokens += 6
+        else:
+            num_tokens += 3
+        return num_tokens
+
+    def compute_remaining_tokens(self, prompts: list) -> int:
+        val = self.compute_required_tokens(prompts)
+        return min(self.max_context_tokens - val, self.max_response_tokens)
+
+    def _is_reasoning_model(self) -> bool:
+        return self.model in SUPPORTED_REASONING_MODELS or self.model in {
+            "gpt-5.1-chat-latest",
+            "gpt-5-pro",
+            "o3-pro",
+        }
+
+    def _handle_image_content(self, content: str) -> list[str]:
+        def _extract_pattern(text):
+            # This regular expression matches <<vision:...:>> patterns to extract embedded image references.
+            pattern = r"<<vision:(.*?):>>"
+            return re.findall(pattern, text)
+
+        image_files: list[str] = []
+        if "<<vision:" not in content:
+            return image_files
+
+        parts = _extract_pattern(content)
+        for p in parts:
+            img_ = p.strip()
+            if img_.startswith("http") or img_.startswith("data:image"):
+                image_files.append(img_)
+            else:
+                max_frames_spacing = 50
+                max_used_frames = 10
+                if img_.startswith("frames:"):
+                    img_ = img_.replace("frames:", "")
+                    max_used_frames, img_ = img_.split(":")
+                    max_used_frames = int(max_used_frames)
+                    if max_used_frames < 1 or max_used_frames > max_frames_spacing:
+                        UserMessage(
+                            f"Invalid max_used_frames value: {max_used_frames}. Expected 1-{max_frames_spacing}",
+                            raise_with=ValueError,
+                        )
+                buffer, ext = encode_media_frames(img_)
+                if len(buffer) > 1:
+                    step = len(buffer) // max_frames_spacing
+                    indices = list(range(0, len(buffer), step))[:max_used_frames]
+                    for i in indices:
+                        image_files.append(f"data:image/{ext};base64,{buffer[i]}")
+                elif len(buffer) == 1:
+                    image_files.append(f"data:image/{ext};base64,{buffer[0]}")
+                else:
+                    UserMessage("No frames found or error in encoding frames")
+        return image_files
+
+    def _remove_vision_pattern(self, text: str) -> str:
+        # This regular expression matches <<vision:...:>> patterns to strip them from output text.
+        pattern = r"<<vision:(.*?):>>"
+        return re.sub(pattern, "", text)
+
+    def _build_system_content(self, argument, image_files: list[str]) -> str:
+        sections: list[str] = []
+        sections.extend(self._verbose_section(argument))
+        sections.extend(self._response_format_section(argument))
+        sections.extend(self._context_sections(argument))
+        sections.extend(self._payload_section(argument))
+        sections.extend(self._examples_section(argument))
+        sections.extend(self._instruction_section(argument, image_files))
+        sections.extend(self._template_suffix_section(argument))
+        return "".join(sections)
+
+    def _verbose_section(self, argument) -> list[str]:
+        if argument.prop.suppress_verbose_output:
+            return [_NON_VERBOSE_OUTPUT]
+        return []
+
+    def _response_format_section(self, argument) -> list[str]:
+        if (
+            argument.prop.response_format
+            and argument.prop.response_format.get("type") == "json_object"
+        ):
+            return ["<RESPONSE_FORMAT/>\nYou are a helpful assistant designed to output JSON.\n\n"]
+        return []
+
+    def _context_sections(self, argument) -> list[str]:
+        sections: list[str] = []
+        static_ctxt, dyn_ctxt = argument.prop.instance.global_context
+        if len(static_ctxt) > 0:
+            sections.append(f"<STATIC CONTEXT/>\n{static_ctxt}\n\n")
+        if len(dyn_ctxt) > 0:
+            sections.append(f"<DYNAMIC CONTEXT/>\n{dyn_ctxt}\n\n")
+        return sections
+
+    def _payload_section(self, argument) -> list[str]:
+        if argument.prop.payload:
+            return [f"<ADDITIONAL CONTEXT/>\n{argument.prop.payload!s}\n\n"]
+        return []
+
+    def _examples_section(self, argument) -> list[str]:
+        examples = argument.prop.examples
+        if examples and len(examples) > 0:
+            return [f"<EXAMPLES/>\n{examples!s}\n\n"]
+        return []
+
+    def _instruction_section(self, argument, image_files: list[str]) -> list[str]:
+        if argument.prop.prompt is None or len(argument.prop.prompt) == 0:
+            return []
+        val = str(argument.prop.prompt)
+        if len(image_files) > 0:
+            val = self._remove_vision_pattern(val)
+        return [f"<INSTRUCTION/>\n{val}\n\n"]
+
+    def _template_suffix_section(self, argument) -> list[str]:
+        if argument.prop.template_suffix:
+            return [
+                f" You will only generate content for the placeholder `{argument.prop.template_suffix!s}` "
+                "following the instructions and the provided context information.\n\n"
+            ]
+        return []
+
+    def _build_user_text(self, argument, image_files: list[str]) -> str:
+        suffix = str(argument.prop.processed_input)
+        if len(image_files) > 0:
+            suffix = self._remove_vision_pattern(suffix)
+        return suffix
+
+    def _create_user_message(self, user_text: str, image_files: list[str]) -> dict:
+        if image_files:
+            images = [{"type": "input_image", "image_url": f} for f in image_files]
+            return {"role": "user", "content": [*images, {"type": "input_text", "text": user_text}]}
+        return {"role": "user", "content": user_text}
+
+    def _apply_self_prompt_if_needed(
+        self, argument, system: str, user_msg: dict, user_text: str, image_files: list[str]
+    ) -> tuple[str, dict]:
+        if not (
+            argument.prop.instance._kwargs.get("self_prompt", False) or argument.prop.self_prompt
+        ):
+            return system, user_msg
+        self_prompter = SelfPrompt()
+        key = "developer" if self._is_reasoning_model() else "system"
+        res = self_prompter({"user": user_text, key: system})
+        if res is None:
+            UserMessage("Self-prompting failed!", raise_with=ValueError)
+        new_user_msg = self._create_user_message(res["user"], image_files)
+        return res[key], new_user_msg
+
+    def _prepare_raw_input(self, argument):
+        if not argument.prop.processed_input:
+            UserMessage(
+                "Need to provide a prompt instruction to the engine if raw_input is enabled.",
+                raise_with=ValueError,
+            )
+        value = argument.prop.processed_input
+        if not isinstance(value, list):
+            if not isinstance(value, dict):
+                value = {"role": "user", "content": str(value)}
+            value = [value]
+        return value
+
+    def prepare(self, argument):
+        if argument.prop.raw_input:
+            argument.prop.prepared_input = self._prepare_raw_input(argument)
+            return
+
+        image_files = self._handle_image_content(str(argument.prop.processed_input))
+        system_content = self._build_system_content(argument, image_files)
+        user_text = self._build_user_text(argument, image_files)
+        user_msg = self._create_user_message(user_text, image_files)
+        system_content, user_msg = self._apply_self_prompt_if_needed(
+            argument, system_content, user_msg, user_text, image_files
+        )
+
+        role = "developer" if self._is_reasoning_model() else "system"
+        argument.prop.prepared_input = [
+            {"role": role, "content": system_content},
+            user_msg,
+        ]
+
+    def _prepare_request_payload(self, messages, argument) -> dict:
+        kwargs = argument.kwargs
+        max_tokens = kwargs.get("max_tokens")
+        max_output_tokens = kwargs.get("max_output_tokens")
+        remaining_tokens = self.compute_remaining_tokens(messages)
+
+        if max_tokens is not None:
+            UserMessage(
+                "'max_tokens' is deprecated in favor of 'max_output_tokens' for Responses API."
+            )
+            if max_tokens > self.max_response_tokens:
+                max_output_tokens = remaining_tokens
+            else:
+                max_output_tokens = max_tokens
+
+        if max_output_tokens is not None and max_output_tokens > self.max_response_tokens:
+            UserMessage(
+                f"Provided 'max_output_tokens' ({max_output_tokens}) exceeds max ({self.max_response_tokens}). "
+                f"Truncating to {remaining_tokens}."
+            )
+            max_output_tokens = remaining_tokens
+
+        payload: dict = {
+            "model": kwargs.get("model", self.model),
+            "input": messages,
+        }
+
+        if max_output_tokens is not None:
+            payload["max_output_tokens"] = max_output_tokens
+
+        if kwargs.get("temperature") is not None and not self._is_reasoning_model():
+            payload["temperature"] = kwargs["temperature"]
+        if kwargs.get("top_p") is not None and not self._is_reasoning_model():
+            payload["top_p"] = kwargs["top_p"]
+
+        if self._is_reasoning_model():
+            if self.model == "gpt-5-pro":
+                reasoning = {"effort": "high"}
+            else:
+                reasoning = kwargs.get("reasoning", {"effort": "medium"})
+            payload["reasoning"] = reasoning
+
+        tools = kwargs.get("tools")
+        if tools:
+            payload["tools"] = self._convert_tools(tools)
+            tool_choice = kwargs.get("tool_choice", "auto")
+            payload["tool_choice"] = tool_choice
+
+        if kwargs.get("response_format"):
+            payload["text"] = {"format": kwargs["response_format"]}
+
+        return payload
+
+    def _convert_tools(self, tools: list) -> list:
+        converted = []
+        for tool in tools:
+            if tool.get("type") == "function":
+                converted.append(
+                    {
+                        "type": "function",
+                        "name": tool.get("name") or tool.get("function", {}).get("name"),
+                        "description": tool.get("description")
+                        or tool.get("function", {}).get("description"),
+                        "parameters": tool.get("parameters")
+                        or tool.get("function", {}).get("parameters"),
+                    }
+                )
+            else:
+                converted.append(tool)
+        return converted
+
+    def _extract_output_text(self, response) -> list[str]:
+        outputs: list[str] = []
+        for output in response.output or []:
+            if output.type == "message" and output.content:
+                for content in output.content:
+                    if hasattr(content, "text"):
+                        outputs.append(content.text)
+        if not outputs and hasattr(response, "output_text") and response.output_text:
+            outputs.append(response.output_text)
+        return outputs
+
+    def _process_function_calls(self, response, metadata: dict) -> dict:
+        for output in response.output or []:
+            if output.type == "function_call":
+                try:
+                    args_dict = json.loads(output.arguments)
+                except json.JSONDecodeError:
+                    args_dict = {}
+                metadata["function_call"] = {
+                    "name": output.name,
+                    "arguments": args_dict,
+                    "call_id": output.call_id,
+                }
+                break
+        return metadata
+
+    def _extract_thinking(self, response) -> str | None:
+        if not self._is_reasoning_model():
+            return None
+        for output in response.output or []:
+            if output.type == "reasoning" and hasattr(output, "summary") and output.summary:
+                texts = [s.text for s in output.summary if hasattr(s, "text") and s.text]
+                if texts:
+                    return "\n".join(texts)
+        return None
+
+    def forward(self, argument):
+        kwargs = argument.kwargs
+        messages = argument.prop.prepared_input
+        payload = self._prepare_request_payload(messages, argument)
+        except_remedy = kwargs.get("except_remedy")
+
+        try:
+            res = self.client.responses.create(**payload)
+        except Exception as e:
+            if openai.api_key is None or openai.api_key == "":
+                msg = "OpenAI API key is not set."
+                UserMessage(msg)
+                if (
+                    self.config["NEUROSYMBOLIC_ENGINE_API_KEY"] is None
+                    or self.config["NEUROSYMBOLIC_ENGINE_API_KEY"] == ""
+                ):
+                    UserMessage(msg, raise_with=ValueError)
+                openai.api_key = self.config["NEUROSYMBOLIC_ENGINE_API_KEY"]
+
+            callback = self.client.responses.create
+            if except_remedy is not None:
+                res = except_remedy(self, e, callback, argument)
+            else:
+                UserMessage(f"Error during generation. Caused by: {e}", raise_with=ValueError)
+
+        metadata = {"raw_output": res}
+        if payload.get("tools"):
+            metadata = self._process_function_calls(res, metadata)
+
+        thinking = self._extract_thinking(res)
+        if thinking:
+            metadata["thinking"] = thinking
+
+        output = self._extract_output_text(res)
+        if not output and "function_call" in metadata:
+            output = [""]
+        return output, metadata

symai/backend/engines/search/engine_parallel.py

@@ -298,6 +298,7 @@ class ExtractResult(Result):
 
 class ParallelEngine(Engine):
     MAX_INCLUDE_DOMAINS = 10
+    MAX_EXCLUDE_DOMAINS = 10
 
     def __init__(self, api_key: str | None = None):
         super().__init__()
@@ -350,7 +351,6 @@ class ParallelEngine(Engine):
             if not netloc or netloc in seen:
                 continue
             if not self._is_valid_domain(netloc):
-                # Skip strings that are not apex domains or bare TLD patterns
                 continue
             seen.add(netloc)
             out.append(netloc)
@@ -358,6 +358,23 @@ class ParallelEngine(Engine):
                 break
         return out
 
+    def _normalize_exclude_domains(self, domains: list[str] | None) -> list[str]:
+        if not isinstance(domains, list):
+            return []
+        seen: set[str] = set()
+        out: list[str] = []
+        for d in domains:
+            netloc = self._extract_netloc(d)
+            if not netloc or netloc in seen:
+                continue
+            if not self._is_valid_domain(netloc):
+                continue
+            seen.add(netloc)
+            out.append(netloc)
+            if len(out) >= self.MAX_EXCLUDE_DOMAINS:
+                break
+        return out
+
     def _coerce_search_queries(self, value: Any) -> list[str]:
         if value is None:
             return []
@@ -411,7 +428,14 @@ class ParallelEngine(Engine):
         max_chars_per_result = kwargs.get("max_chars_per_result", 15000)
         excerpts = {"max_chars_per_result": max_chars_per_result}
         include = self._normalize_include_domains(kwargs.get("allowed_domains"))
-        source_policy = {"include_domains": include} if include else None
+        exclude = self._normalize_exclude_domains(kwargs.get("excluded_domains"))
+        source_policy: dict[str, Any] | None = None
+        if include or exclude:
+            source_policy = {}
+            if include:
+                source_policy["include_domains"] = include
+            if exclude:
+                source_policy["exclude_domains"] = exclude
         objective = kwargs.get("objective")
 
         try:
@@ -432,7 +456,14 @@ class ParallelEngine(Engine):
         task_input = self._compose_task_input(queries)
 
         include = self._normalize_include_domains(kwargs.get("allowed_domains"))
-        source_policy = {"include_domains": include} if include else None
+        exclude = self._normalize_exclude_domains(kwargs.get("excluded_domains"))
+        source_policy: dict[str, Any] | None = None
+        if include or exclude:
+            source_policy = {}
+            if include:
+                source_policy["include_domains"] = include
+            if exclude:
+                source_policy["exclude_domains"] = exclude
         metadata = self._coerce_metadata(kwargs.get("metadata"))
 
         output_schema = (

symai/backend/mixin/__init__.py

@@ -1,5 +1,7 @@
 from .anthropic import SUPPORTED_CHAT_MODELS as ANTHROPIC_CHAT_MODELS
 from .anthropic import SUPPORTED_REASONING_MODELS as ANTHROPIC_REASONING_MODELS
+from .cerebras import SUPPORTED_CHAT_MODELS as CEREBRAS_CHAT_MODELS
+from .cerebras import SUPPORTED_REASONING_MODELS as CEREBRAS_REASONING_MODELS
 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
@@ -8,10 +10,13 @@ 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
+from .openai import SUPPORTED_RESPONSES_MODELS as OPENAI_RESPONSES_MODELS
 
 __all__ = [
     "ANTHROPIC_CHAT_MODELS",
     "ANTHROPIC_REASONING_MODELS",
+    "CEREBRAS_CHAT_MODELS",
+    "CEREBRAS_REASONING_MODELS",
     "DEEPSEEK_CHAT_MODELS",
     "DEEPSEEK_REASONING_MODELS",
     "GOOGLE_CHAT_MODELS",
@@ -20,4 +25,5 @@ __all__ = [
     "GROQ_REASONING_MODELS",
     "OPENAI_CHAT_MODELS",
     "OPENAI_REASONING_MODELS",
+    "OPENAI_RESPONSES_MODELS",
 ]

symai/backend/mixin/anthropic.py

@@ -10,6 +10,7 @@ SUPPORTED_CHAT_MODELS = [
     "claude-3-haiku-20240307",
 ]
 SUPPORTED_REASONING_MODELS = [
+    "claude-opus-4-5",
     "claude-opus-4-1",
     "claude-opus-4-0",
     "claude-sonnet-4-0",
@@ -22,7 +23,8 @@ SUPPORTED_REASONING_MODELS = [
 class AnthropicMixin:
     def api_max_context_tokens(self):
         if (
-            self.model == "claude-opus-4-1"
+            self.model == "claude-opus-4-5"
+            or self.model == "claude-opus-4-1"
             or self.model == "claude-opus-4-0"
             or self.model == "claude-sonnet-4-0"
             or self.model == "claude-3-7-sonnet-latest"
@@ -41,7 +43,8 @@ class AnthropicMixin:
 
     def api_max_response_tokens(self):
         if (
-            self.model == "claude-sonnet-4-0"
+            self.model == "claude-opus-4-5"
+            or self.model == "claude-sonnet-4-0"
             or self.model == "claude-3-7-sonnet-latest"
             or self.model == "claude-haiku-4-5"
             or self.model == "claude-sonnet-4-5"

symai/backend/mixin/cerebras.py

@@ -0,0 +1,9 @@
+SUPPORTED_CHAT_MODELS: list[str] = [
+    "cerebras:qwen-3-235b-a22b-instruct-2507",
+]
+
+SUPPORTED_REASONING_MODELS: list[str] = [
+    "cerebras:zai-glm-4.6",
+    "cerebras:gpt-oss-120b",
+    "cerebras:qwen-3-32b",
+]

symai/backend/mixin/openai.py

@@ -38,6 +38,9 @@ SUPPORTED_EMBEDDING_MODELS = [
     "text-embedding-3-small",
     "text-embedding-3-large",
 ]
+SUPPORTED_RESPONSES_MODELS = [
+    f"responses:{m}" for m in SUPPORTED_CHAT_MODELS + SUPPORTED_REASONING_MODELS
+] + ["responses:gpt-5-pro", "responses:o3-pro"]
 
 
 class OpenAIMixin:
@@ -89,6 +92,7 @@ class OpenAIMixin:
             self.model == "o1"
             or self.model == "o3"
             or self.model == "o3-mini"
+            or self.model == "o3-pro"
             or self.model == "o4-mini"
             or self.model == "gpt-5-chat-latest"
             or self.model == "gpt-5.1-chat-latest"
@@ -99,6 +103,7 @@ class OpenAIMixin:
             or self.model == "gpt-5.1"
             or self.model == "gpt-5-mini"
             or self.model == "gpt-5-nano"
+            or self.model == "gpt-5-pro"
         ):
             return 400_000
         if self.model == "gpt-4.1" or self.model == "gpt-4.1-mini" or self.model == "gpt-4.1-nano":
@@ -138,6 +143,7 @@ class OpenAIMixin:
             self.model == "o1"
             or self.model == "o3"
             or self.model == "o3-mini"
+            or self.model == "o3-pro"
             or self.model == "o4-mini"
         ):
             return 100_000
@@ -148,6 +154,8 @@ class OpenAIMixin:
             or self.model == "gpt-5-nano"
         ):
             return 128_000
+        if self.model == "gpt-5-pro":
+            return 272_000
         msg = f"Unsupported model: {self.model}"
         UserMessage(msg)
         raise ValueError(msg)

symai/components.py

@@ -1282,6 +1282,7 @@ class MetadataTracker(Expression):
                     token_details[(engine_name, None)]["completion_breakdown"][
                         "reasoning_tokens"
                     ] += 0
+                    self._track_parallel_usage_items(token_details, engine_name, metadata)
                 elif engine_name in ("GPTXChatEngine", "GPTXReasoningEngine"):
                     usage = metadata["raw_output"].usage
                     token_details[(engine_name, model_name)]["usage"]["completion_tokens"] += (
@@ -1312,7 +1313,7 @@ class MetadataTracker(Expression):
                     token_details[(engine_name, model_name)]["prompt_breakdown"][
                         "cached_tokens"
                     ] += usage.prompt_tokens_details.cached_tokens
-                elif engine_name == "GPTXSearchEngine":
+                elif engine_name in ("GPTXSearchEngine", "OpenAIResponsesEngine"):
                     usage = metadata["raw_output"].usage
                     token_details[(engine_name, model_name)]["usage"]["prompt_tokens"] += (
                         usage.input_tokens
@@ -1330,6 +1331,25 @@ class MetadataTracker(Expression):
                     token_details[(engine_name, model_name)]["completion_breakdown"][
                         "reasoning_tokens"
                     ] += usage.output_tokens_details.reasoning_tokens
+                elif engine_name == "CerebrasEngine":
+                    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
                 else:
                     logger.warning(f"Tracking {engine_name} is not supported.")
                     continue
@@ -1345,6 +1365,19 @@ class MetadataTracker(Expression):
         supported_engines = ("GPTXChatEngine", "GPTXReasoningEngine", "GPTXSearchEngine")
         return engine_name in supported_engines
 
+    def _track_parallel_usage_items(self, token_details, engine_name, metadata):
+        usage_items = getattr(metadata.get("raw_output", None), "usage", None)
+        if not usage_items:
+            return
+        if isinstance(usage_items, dict):
+            usage_items = usage_items.values()
+        extras = token_details[(engine_name, None)].setdefault("extras", {})
+        for item in usage_items:
+            name = getattr(item, "name", None)
+            count = getattr(item, "count", None)
+            if name in ("sku_search", "sku_extract_excerpts") and isinstance(count, (int, float)):
+                extras[name] = extras.get(name, 0) + count
+
     def _accumulate_time_field(self, accumulated: dict, metadata: dict) -> None:
         if "time" in metadata and "time" in accumulated:
             accumulated["time"] += metadata["time"]
@@ -1475,9 +1508,12 @@ class DynamicEngine(Expression):
         """Create an engine instance based on the model name."""
         # Deferred to avoid components <-> neurosymbolic engine circular imports.
         from .backend.engines.neurosymbolic import ENGINE_MAPPING  # noqa
+        from .backend.engines.neurosymbolic.engine_cerebras import CerebrasEngine  # noqa
 
         try:
             engine_class = ENGINE_MAPPING.get(self.model)
+            if engine_class is None and self.model.startswith("cerebras:"):
+                engine_class = CerebrasEngine
             if engine_class is None:
                 UserMessage(f"Unsupported model '{self.model}'", raise_with=ValueError)
             return engine_class(api_key=self.api_key, model=self.model)

symai/server/qdrant_server.py

@@ -1,4 +1,5 @@
 import argparse
+import os
 import subprocess
 import sys
 from pathlib import Path
@@ -41,6 +42,13 @@ def qdrant_server():  # noqa
         default="./qdrant_storage",
         help="Path to Qdrant storage directory (default: ./qdrant_storage)",
     )
+    parser.add_argument(
+        "--use-env-storage",
+        action="store_true",
+        default=False,
+        help="Use QDRANT__STORAGE__STORAGE_PATH environment variable instead of passing --storage-path. "
+        "If set, storage path argument/volume mount will be skipped, allowing Qdrant to use its own defaults or env vars.",
+    )
     parser.add_argument(
         "--config-path", type=str, default=None, help="Path to Qdrant configuration file"
     )
@@ -62,6 +70,12 @@ def qdrant_server():  # noqa
         default=False,
         help="Run Docker container in detached mode (default: False)",
     )
+    parser.add_argument(
+        "--no-cache",
+        action="store_true",
+        default=False,
+        help="Disable caching in Qdrant server (default: False)",
+    )
 
     main_args, qdrant_args = parser.parse_known_args()
 
@@ -92,15 +106,19 @@ def qdrant_server():  # noqa
         # Build command for binary execution
         command = [main_args.binary_path]
 
-        # Ensure storage directory exists
-        storage_path = Path(main_args.storage_path)
-        storage_path.mkdir(parents=True, exist_ok=True)
-        abs_storage_path = str(storage_path.resolve())
-
-        # Add standard Qdrant arguments
-        # Set storage path via environment variable or command argument
-        # Qdrant binary accepts --storage-path argument
-        command.extend(["--storage-path", abs_storage_path])
+        # Add storage path argument unless --use-env-storage is set
+        if not main_args.use_env_storage:
+            # Ensure storage directory exists
+            storage_path = Path(main_args.storage_path)
+            storage_path.mkdir(parents=True, exist_ok=True)
+            abs_storage_path = str(storage_path.resolve())
+            # Qdrant binary accepts --storage-path argument
+            command.extend(["--storage-path", abs_storage_path])
+        elif os.getenv("QDRANT__STORAGE__STORAGE_PATH"):
+            # If using env storage and env var is set, pass it through
+            # Note: Qdrant binary may read this from env, but we can also pass it explicitly
+            abs_storage_path = os.getenv("QDRANT__STORAGE__STORAGE_PATH")
+            command.extend(["--storage-path", abs_storage_path])
 
         # Add host, port, and grpc-port arguments
         command.extend(["--host", main_args.host])
@@ -110,15 +128,16 @@ def qdrant_server():  # noqa
         if main_args.config_path:
             command.extend(["--config-path", main_args.config_path])
 
+        # Add no-cache environment variable if flag is set
+        if main_args.no_cache:
+            # Set environment variable to disable caching
+            # Qdrant uses environment variables with QDRANT__ prefix
+            os.environ["QDRANT__SERVICE__ENABLE_STATIC_CONTENT_CACHE"] = "false"
+
         # Add any additional Qdrant-specific arguments
         command.extend(qdrant_args)
 
     else:  # docker
-        # Ensure storage directory exists
-        storage_path = Path(main_args.storage_path)
-        storage_path.mkdir(parents=True, exist_ok=True)
-        abs_storage_path = str(storage_path.resolve())
-
         # Build Docker command
         command = ["docker", "run"]
 
@@ -138,8 +157,20 @@ def qdrant_server():  # noqa
         command.extend(["-p", f"{main_args.port}:6333"])
         command.extend(["-p", f"{main_args.grpc_port}:6334"])
 
-        # Volume mount for storage
-        command.extend(["-v", f"{abs_storage_path}:/qdrant/storage:z"])
+        # Volume mount for storage (skip if --use-env-storage is set)
+        if not main_args.use_env_storage:
+            # Ensure storage directory exists
+            storage_path = Path(main_args.storage_path)
+            storage_path.mkdir(parents=True, exist_ok=True)
+            abs_storage_path = str(storage_path.resolve())
+            # Volume mount for storage
+            command.extend(["-v", f"{abs_storage_path}:/qdrant/storage:z"])
+            # Set storage path environment variable to use the mounted volume
+            command.extend(["-e", "QDRANT__STORAGE__STORAGE_PATH=/qdrant/storage"])
+        elif os.getenv("QDRANT__STORAGE__STORAGE_PATH"):
+            # If using env storage and env var is set, pass it through to container
+            env_storage_path = os.getenv("QDRANT__STORAGE__STORAGE_PATH")
+            command.extend(["-e", f"QDRANT__STORAGE__STORAGE_PATH={env_storage_path}"])
 
         # Volume mount for config (if provided)
         # Note: Qdrant Docker image accepts environment variables and config files
@@ -151,8 +182,10 @@ def qdrant_server():  # noqa
             command.extend(["-v", f"{config_dir}:/qdrant/config:z"])
             # Qdrant looks for config.yaml in /qdrant/config by default
 
-        # Set storage path environment variable to use the mounted volume
-        command.extend(["-e", "QDRANT__STORAGE__STORAGE_PATH=/qdrant/storage"])
+        # Add no-cache environment variable if flag is set
+        if main_args.no_cache:
+            # Set environment variable to disable caching in Docker container
+            command.extend(["-e", "QDRANT__SERVICE__ENABLE_STATIC_CONTENT_CACHE=false"])
 
         # Docker image
         command.append(main_args.docker_image)
@@ -176,15 +209,20 @@ def qdrant_server():  # noqa
             str(main_args.port),
             "--grpc-port",
             str(main_args.grpc_port),
-            "--storage-path",
-            main_args.storage_path,
             "--docker-image",
             main_args.docker_image,
             "--docker-container-name",
             main_args.docker_container_name,
         ]
+        # Only include storage-path in config if not using env storage
+        if not main_args.use_env_storage:
+            config_args.extend(["--storage-path", main_args.storage_path])
+        else:
+            config_args.append("--use-env-storage")
         if main_args.config_path:
             config_args.extend(["--config-path", main_args.config_path])
+        if main_args.no_cache:
+            config_args.append("--no-cache")
     else:
         config_args = [
             "--env",
@@ -197,10 +235,15 @@ def qdrant_server():  # noqa
             str(main_args.port),
             "--grpc-port",
             str(main_args.grpc_port),
-            "--storage-path",
-            main_args.storage_path,
         ]
+        # Only include storage-path in config if not using env storage
+        if not main_args.use_env_storage:
+            config_args.extend(["--storage-path", main_args.storage_path])
+        else:
+            config_args.append("--use-env-storage")
         if main_args.config_path:
             config_args.extend(["--config-path", main_args.config_path])
+        if main_args.no_cache:
+            config_args.append("--no-cache")
 
     return command, config_args

symai/utils.py

@@ -4,9 +4,9 @@ import base64
 import inspect
 import os
 import warnings
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import cv2
 import httpx
@@ -217,6 +217,7 @@ class RuntimeInfo:
     total_calls: int
     total_tokens: int
     cost_estimate: float
+    extras: dict[str, Any] = field(default_factory=dict)
 
     def __add__(self, other):
         add_elapsed_time = other.total_elapsed_time if hasattr(other, "total_elapsed_time") else 0
@@ -229,6 +230,17 @@ class RuntimeInfo:
         add_cached_tokens = other.cached_tokens if hasattr(other, "cached_tokens") else 0
         add_reasoning_tokens = other.reasoning_tokens if hasattr(other, "reasoning_tokens") else 0
         add_total_calls = other.total_calls if hasattr(other, "total_calls") else 0
+        extras = other.extras if hasattr(other, "extras") else {}
+        merged_extras = {**(self.extras or {})}
+        for key, value in (extras or {}).items():
+            if (
+                key in merged_extras
+                and isinstance(merged_extras[key], (int, float))
+                and isinstance(value, (int, float))
+            ):
+                merged_extras[key] += value
+            else:
+                merged_extras[key] = value
 
         return RuntimeInfo(
             total_elapsed_time=self.total_elapsed_time + add_elapsed_time,
@@ -239,6 +251,7 @@ class RuntimeInfo:
             total_calls=self.total_calls + add_total_calls,
             total_tokens=self.total_tokens + add_total_tokens,
             cost_estimate=self.cost_estimate + add_cost_estimate,
+            extras=merged_extras,
         )
 
     @staticmethod
@@ -248,7 +261,7 @@ class RuntimeInfo:
                 return RuntimeInfo.from_usage_stats(tracker.usage, total_elapsed_time)
             except Exception as e:
                 UserMessage(f"Failed to parse metadata: {e}", raise_with=ValueError)
-        return RuntimeInfo(0, 0, 0, 0, 0, 0, 0, 0)
+        return RuntimeInfo(0, 0, 0, 0, 0, 0, 0, 0, {})
 
     @staticmethod
     def from_usage_stats(usage_stats: dict | None, total_elapsed_time: float = 0):
@@ -266,9 +279,10 @@ class RuntimeInfo:
                     total_calls=data_box.usage.total_calls,
                     total_tokens=data_box.usage.total_tokens,
                     cost_estimate=0,  # Placeholder for cost estimate
+                    extras=data.get("extras", {}),
                 )
             return usage_per_engine
-        return RuntimeInfo(0, 0, 0, 0, 0, 0, 0, 0)
+        return RuntimeInfo(0, 0, 0, 0, 0, 0, 0, 0, {})
 
     @staticmethod
     def estimate_cost(info: RuntimeInfo, f_pricing: callable, **kwargs) -> RuntimeInfo:
@@ -281,4 +295,5 @@ class RuntimeInfo:
             total_calls=info.total_calls,
             total_tokens=info.total_tokens,
             cost_estimate=f_pricing(info, **kwargs),
+            extras=info.extras,
         )

{symbolicai-1.1.0.dist-info → symbolicai-1.2.0.dist-info}/METADATA

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

{symbolicai-1.1.0.dist-info → symbolicai-1.2.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 symai/TERMS_OF_SERVICE.md,sha256=HN42UXVI_wAVDHjMShzy_k7xAsbjXaATNeMKcIte_eg,91409
-symai/__init__.py,sha256=tfavYhEZTrbPwBKJWYPhxGs1ceV-HDIvPNbxkp8KlKI,18530
+symai/__init__.py,sha256=irjwVGnXl5w5mBwBTT3Z6HyXKjZNdrjEVYiDUxggVfo,18530
 symai/chat.py,sha256=DCEbmZ96wv-eitAVt6-oF6PT3JM3cT59Iy3r2Hucd_M,14100
-symai/components.py,sha256=b8B8AvjbMMEgmFSqpzvLYLUZu6zwRnRc1r2hJWSbf1s,62584
+symai/components.py,sha256=s10kLvwAOjSBQQohoHGtAIKs0UHHCd_HhiRvMbNtIH0,64685
 symai/constraints.py,sha256=ljjB9p0qK4DrDl_u5G_Y-Y6WAH5ZHANIqLLxRtwcORs,1980
 symai/context.py,sha256=4M69MJOeWSdPTr2Y9teoNTs-nEvpzcAcr7900UgORXA,189
 symai/core.py,sha256=gI9qvTT0Skq2D0izdhAoN3RdwBtWei59KO52mKN1Sos,70420
@@ -20,7 +20,7 @@ symai/shellsv.py,sha256=rwTUcgaNdUm4_SRM7u4aMndMaEAaM6jBvWbEQzWoI0c,39831
 symai/strategy.py,sha256=BQTXRnBv57fYO47A--WA6KK1oqGmf9Aijm0p4a_vvqY,45004
 symai/symbol.py,sha256=s5CYwP5SGcRUzZ7TlakZFpKBX_Q0mwPQKRbv4pC3sxM,40443
 symai/symsh.md,sha256=QwY_-fX0Ge7Aazul0xde2DuF2FZLw_elxrkXR3kuKDQ,1245
-symai/utils.py,sha256=oCtrlbOdq9a4cglyKaRNkv5ChprZ7WCqRHNxX0iEyuU,10175
+symai/utils.py,sha256=m4iQzxclkPAUSDderTO_OK2fKznJ69pLfbBcTYq4p70,10824
 symai/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 symai/backend/base.py,sha256=28kIR0NrTL-BgmjpP31JXNlRH4u1TF9qarOXqlCFbVI,7296
 symai/backend/settings.py,sha256=T5iUAV8aGLnQy9iRTvUDJq49LGobiSHPGV1HqBHjkEg,6181
@@ -41,10 +41,10 @@ symai/backend/engines/files/engine_io.py,sha256=4eYBz44rQYWD7VO6Pn7hVF_cOnqNuolo
 symai/backend/engines/imagecaptioning/engine_blip2.py,sha256=8lTzc8sQpuNY4AUb_ZweRKr95v-sFtTykT5ennVf6g0,2915
 symai/backend/engines/imagecaptioning/engine_llavacpp_client.py,sha256=jBsLZv0Laa4tuPyX0VQ7uwyldyO3aYIbbj73WjTbceM,6793
 symai/backend/engines/index/engine_pinecone.py,sha256=fxCew1ldUdjd9UtqnMuWFDiVz5X5BUIKZtq1iSDhj28,9132
-symai/backend/engines/index/engine_qdrant.py,sha256=f2lguAgCTZz2p6UI__u7puxH-X9UteWxBIzQnOUX1Xk,37748
+symai/backend/engines/index/engine_qdrant.py,sha256=GtWVbgaqJuATfGus0A0h7EgM_8hKlbw3fnorNJmbC_Q,43300
 symai/backend/engines/index/engine_vectordb.py,sha256=xXU8QaC2BX9O4dDjDCVYgWO4PxQMpmNlhtal6UVtV0o,8541
 symai/backend/engines/lean/engine_lean4.py,sha256=ln5nbQn5szq8nRulbREPLCPQ5bwjM_A5XAGMkfzPdT8,10102
-symai/backend/engines/neurosymbolic/__init__.py,sha256=TKPs76bp726JQnHpPy-iLGUquZSf5SiUsui7UTLRAxs,1777
+symai/backend/engines/neurosymbolic/__init__.py,sha256=o7HUmxcYSrIkutGYB-6_Qur3adHyrkVeWroDtqEK-YE,2279
 symai/backend/engines/neurosymbolic/engine_anthropic_claudeX_chat.py,sha256=WyuskobMjf9ynxRWUnXk55DUMUN7qv7jT1nbZP3Bx9o,21054
 symai/backend/engines/neurosymbolic/engine_anthropic_claudeX_reasoning.py,sha256=thEPDh8H-5XrsADF0mVTWB6m_dJgKeTT49HvyCGJcQM,21291
 symai/backend/engines/neurosymbolic/engine_cerebras.py,sha256=ki84Qh7hdxaKn--UgMMUvAEoqJos7VeKtkka6XpHI3g,13336
@@ -56,11 +56,12 @@ symai/backend/engines/neurosymbolic/engine_llama_cpp.py,sha256=CWy1aqqV-NFey0b9s
 symai/backend/engines/neurosymbolic/engine_openai_gptX_chat.py,sha256=FfNkesV64d3gf7MWKf2PoK5nUjetS2MndTbWhE1KieE,28267
 symai/backend/engines/neurosymbolic/engine_openai_gptX_completion.py,sha256=YgxRoitmDz2de_W7rkhVXYEkDqTJQlgxK4f8tWlt88Q,13840
 symai/backend/engines/neurosymbolic/engine_openai_gptX_reasoning.py,sha256=yWiCT_jHHQGs2_YqRhSRvVFxQFXGb1TwvXf2zZWoStU,27171
+symai/backend/engines/neurosymbolic/engine_openai_responses.py,sha256=OSqXJIMUWa4BANUhfxZg9lGmO7FE6xM0G_w0aRqODSw,17751
 symai/backend/engines/ocr/engine_apilayer.py,sha256=UpC3oHBdSM6wlPVqxwMkemBd-Y0ReVwc270O_EVbRD0,2267
 symai/backend/engines/output/engine_stdout.py,sha256=BWNXACl5U-WYIJnT1pZNwZsTRMzP1XzA0A7o693mmyQ,899
 symai/backend/engines/scrape/engine_requests.py,sha256=yyVFT9JrZ4S6v5U_cykef-tn5iWGl1MAdpqnDaQ70TA,13821
 symai/backend/engines/search/engine_openai.py,sha256=hAEu3vPZzLTvgmNc4BSZDTcNb4ek4xYeOf8xgti2zRs,14248
-symai/backend/engines/search/engine_parallel.py,sha256=3kqVpbLyh7TXNBFP63A14Akfx8kEu0n0zPjqtf7Ere8,25319
+symai/backend/engines/search/engine_parallel.py,sha256=PybgfkpJ_rA5FkVebZisfXwWIcki2AJPxqZfnWPl5To,26422
 symai/backend/engines/search/engine_perplexity.py,sha256=rXnZjMCSiIRuJcNSchE58-f9zWJmYpkKMHONF_XwGnk,4100
 symai/backend/engines/search/engine_serpapi.py,sha256=ZJJBnEDoLjkpxWt_o4vFZanwqojH8ZFBWmWNnEaIbww,3618
 symai/backend/engines/speech_to_text/engine_local_whisper.py,sha256=EOUh2GCeEhZ2Av72i_AZ4NSj9e46Pl7Ft6sIErFy6FI,8387
@@ -68,12 +69,13 @@ symai/backend/engines/symbolic/engine_wolframalpha.py,sha256=mTH0N4rA0gMffSBLjf2
 symai/backend/engines/text_to_speech/engine_openai.py,sha256=AtY0mDvIM_yZQ6AgYNXuyinZr_OaMK7XiPLQ6fe6RBo,2013
 symai/backend/engines/text_vision/engine_clip.py,sha256=hU9vsHtKPpQYEoESyjuGXOzMhUNhvspYMCNkCAqn2x8,3648
 symai/backend/engines/userinput/engine_console.py,sha256=fDO6PRQI3NYZ_nHVXDFIsS9cFDRv3aTOfv8h5a360jc,743
-symai/backend/mixin/__init__.py,sha256=yGo_NQjG5r7Y1_fXCXPMvLFxNrqB_dA60rQ0CXITLRo,1008
-symai/backend/mixin/anthropic.py,sha256=kTHJnFlmgqN6X5fjsAnwSwZ6Qdhr-Zo5vI46_D9Ke3Y,2286
+symai/backend/mixin/__init__.py,sha256=rJjz7OSR2Qp_gl9KCL6ILuUh1BduKRPLSiWYIQuBIv4,1320
+symai/backend/mixin/anthropic.py,sha256=GdHimGqiJcA21Jo797ZEeFzotRpCOJdBJQIChl_6NJI,2403
+symai/backend/mixin/cerebras.py,sha256=MEc9vQ6G4KWWrt0NFjdt2y0rojhtBidwa_n4M8Z5EKI,215
 symai/backend/mixin/deepseek.py,sha256=7TnyqXQb2t6r6-hzOClPzxfO2d7TShYC989Lmn_YTzM,414
 symai/backend/mixin/google.py,sha256=N1xxrrTcQkcKJtdPbRorev6dfJ1F65I5XavrGR06GN4,494
 symai/backend/mixin/groq.py,sha256=at6yFLa35Js8o7D8p_-Y4NjOPJI-lH8yx6tsCDrEy6M,227
-symai/backend/mixin/openai.py,sha256=y-QutoEQc3JwM9OIx43JBCB2HaTC1t8nOsA3uEoTImc,5135
+symai/backend/mixin/openai.py,sha256=Skwn3JnXtrH0TWSJbojkMBpSkCEvtD4FesmPY6KCD70,5477
 symai/collect/__init__.py,sha256=YD1UQoD4Z-_AodqTp48Vv-3UHYUa1g4lZnhm2AsjCd0,202
 symai/collect/dynamic.py,sha256=72oEdshjue3t_Zs_3D08bhHPKN5mKAw0HEucWAFlqVI,3833
 symai/collect/pipeline.py,sha256=eyxqqNpa1P5xEL50WgUZT6Z-MRocuLRBqexkVIqWqv8,5360
@@ -159,10 +161,10 @@ symai/ops/primitives.py,sha256=c0GT8rGL2p7dIL-yNoAydpwSZWx__8Ep8T2jj9Q5Eqw,11636
 symai/server/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 symai/server/huggingface_server.py,sha256=wSAVqFiKQsCu5UB2YYVpxJBhJ7GgQBBfePxNi265yP8,9039
 symai/server/llama_cpp_server.py,sha256=-WPTNB2cbnwtnpES4AtPM__MCasDKl83jr94JGS9tmI,2144
-symai/server/qdrant_server.py,sha256=pOm382ZmPJ2jlJiLIxt_KUJqISOgWiKhs3Ojbp5REOI,7420
-symbolicai-1.1.0.dist-info/licenses/LICENSE,sha256=9vRFudlJ1ghVfra5lcCUIYQCqnZSYcBLjLHbGRsrQCs,1505
-symbolicai-1.1.0.dist-info/METADATA,sha256=IrMaEQXGdoacrMYuIiWkqOuCoEdCo7s80Igr0rGrjI4,23603
-symbolicai-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-symbolicai-1.1.0.dist-info/entry_points.txt,sha256=JV5sdydIfUZdDF6QBEQHiZHod6XNPjCjpWQrXh7gTAw,261
-symbolicai-1.1.0.dist-info/top_level.txt,sha256=bOoIDfpDIvCQtQgXcwVKJvxAKwsxpxo2IL4z92rNJjw,6
-symbolicai-1.1.0.dist-info/RECORD,,
+symai/server/qdrant_server.py,sha256=l4r4rz29c7cO1dapXO0LQ4sHW4WF44keuz7j8v5azMc,9854
+symbolicai-1.2.0.dist-info/licenses/LICENSE,sha256=9vRFudlJ1ghVfra5lcCUIYQCqnZSYcBLjLHbGRsrQCs,1505
+symbolicai-1.2.0.dist-info/METADATA,sha256=hm-h6TAae8Otfn9oKVPRMjNyRGrQHSVs99j2Sq_QWik,23603
+symbolicai-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+symbolicai-1.2.0.dist-info/entry_points.txt,sha256=JV5sdydIfUZdDF6QBEQHiZHod6XNPjCjpWQrXh7gTAw,261
+symbolicai-1.2.0.dist-info/top_level.txt,sha256=bOoIDfpDIvCQtQgXcwVKJvxAKwsxpxo2IL4z92rNJjw,6
+symbolicai-1.2.0.dist-info/RECORD,,