symbolicai 1.5.0__py3-none-any.whl → 1.7.0__py3-none-any.whl

symai/__init__.py

@@ -11,8 +11,6 @@ from rich.table import Table
 from rich.tree import Tree
 
 from .backend import settings
-from .menu.screen import show_intro_menu
-from .misc.console import ConsoleStyle
 from .utils import UserMessage
 
 # do not remove - hides the libraries' debug messages
@@ -33,7 +31,7 @@ os.environ["TOKENIZERS_PARALLELISM"] = "false"
 # Create singleton instance
 config_manager = settings.SymAIConfig()
 
-SYMAI_VERSION = "1.5.0"
+SYMAI_VERSION = "1.7.0"
 __version__ = SYMAI_VERSION
 __root_dir__ = config_manager.config_dir
 
@@ -87,20 +85,6 @@ def _start_symai():
     # Load and manage configurations
     symai_config = config_manager.load_config("symai.config.json")
 
-    # MIGRATE THE ENVIRONMENT VARIABLES
-    # *==========================================================================================================*
-    if "COLLECTION_URI" not in symai_config:
-        updates = {
-            "COLLECTION_URI": "mongodb+srv://User:vt3epocXitd6WlQ6@extensityai.c1ajxxy.mongodb.net/?retryWrites=true&w=majority",
-            "COLLECTION_DB": "ExtensityAI",
-            "COLLECTION_STORAGE": "SymbolicAI",
-            "SUPPORT_COMMUNITY": False,
-        }
-        config_manager.migrate_config("symai.config.json", updates)
-        with ConsoleStyle("info") as console:
-            msg = "Currently you are sharing your user experience with us by uploading the data to our research server, and thereby helping us improve future models and the overall SymbolicAI experience. We thank you very much for supporting the research community! If you wish to disable the data collection option go to your .symai config situated in your home directory or set the environment variable `SUPPORT_COMMUNITY` to `False`."
-            console.print(msg)
-
     # POST-MIGRATION CHECKS
     # *==============================================================================================================*
     if "TEXT_TO_SPEECH_ENGINE_API_KEY" not in symai_config:
@@ -114,11 +98,6 @@ def _start_symai():
     symsh_config = config_manager.load_config("symsh.config.json")
     symserver_config = config_manager.load_config("symserver.config.json")
 
-    # MIGRATE THE SHELL SPLASH SCREEN CONFIGURATION
-    # *==============================================================================================================*
-    if "show-splash-screen" not in symsh_config:
-        config_manager.migrate_config("symsh.config.json", {"show-splash-screen": True})
-
     # CHECK IF THE USER HAS A NEUROSYMBOLIC API KEY
     # *==============================================================================================================*
     if not (
@@ -130,7 +109,6 @@ def _start_symai():
     ):
         # Try to fallback to the global (home) config if environment is not home
         if config_manager.config_dir != config_manager._home_config_dir:
-            show_intro_menu()
             UserMessage(
                 f"You didn't configure your environment ({config_manager.config_dir})! Falling back to the global ({config_manager._home_config_dir}) configuration if it exists."
             )
@@ -345,57 +323,29 @@ def display_config():
 
 
 def setup_wizard(_symai_config_path_):
-    show_intro_menu()
-
-    _nesy_engine_api_key = ""
-    _nesy_engine_model = ""
-    _symbolic_engine_api_key = ""
-    _symbolic_engine_model = ""
-    _embedding_engine_api_key = ""
-    _embedding_model = ""
-    _drawing_engine_api_key = ""
-    _drawing_engine_model = ""
-    _vision_engine_model = ""
-    _search_engine_api_key = ""
-    _search_engine_model = ""
-    _ocr_engine_api_key = ""
-    _speech_to_text_engine_model = ""
-    _speech_to_text_api_key = ""
-    _text_to_speech_engine_api_key = ""
-    _text_to_speech_engine_model = ""
-    _text_to_speech_engine_voice = ""
-    _indexing_engine_api_key = ""
-    _indexing_engine_environment = ""
-    _caption_engine_environment = ""
-    _support_comminity = False
-
     config_manager.save_config(
         _symai_config_path_,
         {
-            "NEUROSYMBOLIC_ENGINE_API_KEY": _nesy_engine_api_key,
-            "NEUROSYMBOLIC_ENGINE_MODEL": _nesy_engine_model,
-            "SYMBOLIC_ENGINE_API_KEY": _symbolic_engine_api_key,
-            "SYMBOLIC_ENGINE": _symbolic_engine_model,
-            "EMBEDDING_ENGINE_API_KEY": _embedding_engine_api_key,
-            "EMBEDDING_ENGINE_MODEL": _embedding_model,
-            "DRAWING_ENGINE_API_KEY": _drawing_engine_api_key,
-            "DRAWING_ENGINE_MODEL": _drawing_engine_model,
-            "VISION_ENGINE_MODEL": _vision_engine_model,
-            "SEARCH_ENGINE_API_KEY": _search_engine_api_key,
-            "SEARCH_ENGINE_MODEL": _search_engine_model,
-            "OCR_ENGINE_API_KEY": _ocr_engine_api_key,
-            "SPEECH_TO_TEXT_ENGINE_MODEL": _speech_to_text_engine_model,
-            "SPEECH_TO_TEXT_API_KEY": _speech_to_text_api_key,
-            "TEXT_TO_SPEECH_ENGINE_API_KEY": _text_to_speech_engine_api_key,
-            "TEXT_TO_SPEECH_ENGINE_MODEL": _text_to_speech_engine_model,
-            "TEXT_TO_SPEECH_ENGINE_VOICE": _text_to_speech_engine_voice,
-            "INDEXING_ENGINE_API_KEY": _indexing_engine_api_key,
-            "INDEXING_ENGINE_ENVIRONMENT": _indexing_engine_environment,
-            "CAPTION_ENGINE_MODEL": _caption_engine_environment,
-            "COLLECTION_URI": "mongodb+srv://User:vt3epocXitd6WlQ6@extensityai.c1ajxxy.mongodb.net/?retryWrites=true&w=majority",
-            "COLLECTION_DB": "ExtensityAI",
-            "COLLECTION_STORAGE": "SymbolicAI",
-            "SUPPORT_COMMUNITY": _support_comminity,
+            "NEUROSYMBOLIC_ENGINE_API_KEY": "",
+            "NEUROSYMBOLIC_ENGINE_MODEL": "",
+            "SYMBOLIC_ENGINE_API_KEY": "",
+            "SYMBOLIC_ENGINE": "",
+            "EMBEDDING_ENGINE_API_KEY": "",
+            "EMBEDDING_ENGINE_MODEL": "",
+            "DRAWING_ENGINE_API_KEY": "",
+            "DRAWING_ENGINE_MODEL": "",
+            "VISION_ENGINE_MODEL": "",
+            "SEARCH_ENGINE_API_KEY": "",
+            "SEARCH_ENGINE_MODEL": "",
+            "OCR_ENGINE_API_KEY": "",
+            "SPEECH_TO_TEXT_ENGINE_MODEL": "",
+            "SPEECH_TO_TEXT_API_KEY": "",
+            "TEXT_TO_SPEECH_ENGINE_API_KEY": "",
+            "TEXT_TO_SPEECH_ENGINE_MODEL": "",
+            "TEXT_TO_SPEECH_ENGINE_VOICE": "",
+            "INDEXING_ENGINE_API_KEY": "",
+            "INDEXING_ENGINE_ENVIRONMENT": "",
+            "CAPTION_ENGINE_MODEL": "",
         },
     )
 

symai/backend/base.py

@@ -3,21 +3,11 @@ import time
 from abc import ABC, abstractmethod
 from typing import Any
 
-from ..collect import CollectionRepository, rec_serialize
 from ..utils import UserMessage
 from .settings import HOME_PATH
 
 ENGINE_UNREGISTERED = "<UNREGISTERED/>"
 
-COLLECTION_LOGGING_ENGINES = {
-    "GPTXChatEngine",
-    "GPTXCompletionEngine",
-    "SerpApiEngine",
-    "WolframAlphaEngine",
-    "SeleniumEngine",
-    "OCREngine",
-}
-
 
 class Engine(ABC):
     def __init__(self) -> None:
@@ -26,8 +16,6 @@ class Engine(ABC):
         self.logging = False
         self.log_level = logging.DEBUG
         self.time_clock = False
-        self.collection = CollectionRepository()
-        self.collection.connect()
         # create formatter
         __root_dir__ = HOME_PATH
         __root_dir__.mkdir(parents=True, exist_ok=True)
@@ -66,9 +54,6 @@ class Engine(ABC):
         if self.logging:
             self.logger.log(self.log_level, log)
 
-        if str(self) in COLLECTION_LOGGING_ENGINES:
-            self._record_collection_entry(argument, metadata, req_time)
-
         self._trigger_output_handlers(argument, res, metadata)
         return res, metadata
 
@@ -92,17 +77,6 @@ class Engine(ABC):
         if argument_handler:
             argument_handler((result, metadata))
 
-    def _record_collection_entry(self, argument: Any, metadata: dict, req_time: float) -> None:
-        self.collection.add(
-            forward={"args": rec_serialize(argument.args), "kwds": rec_serialize(argument.kwargs)},
-            engine=str(self),
-            metadata={
-                "time": req_time,
-                "data": rec_serialize(metadata),
-                "argument": rec_serialize(argument),
-            },
-        )
-
     def id(self) -> str:
         return ENGINE_UNREGISTERED
 

symai/backend/engines/drawing/engine_gemini_image.py

@@ -0,0 +1,101 @@
+import base64
+import logging
+import mimetypes
+import tempfile
+from pathlib import Path
+
+from google import genai
+from google.genai import types
+
+from ....symbol import Result
+from ....utils import UserMessage
+from ...base import Engine
+from ...settings import SYMAI_CONFIG
+
+logging.getLogger("google.genai").setLevel(logging.ERROR)
+logging.getLogger("google_genai").propagate = False
+
+
+class GeminiImageResult(Result):
+    def __init__(self, value, **kwargs):
+        super().__init__(value, **kwargs)
+        paths = []
+        for candidate in getattr(value, "candidates", []) or []:
+            content = getattr(candidate, "content", None)
+            parts = getattr(content, "parts", []) if content else []
+            for part in parts:
+                inline_data = getattr(part, "inline_data", None)
+                if inline_data is None:
+                    continue
+                mime_type = getattr(inline_data, "mime_type", None) or "image/png"
+                data = getattr(inline_data, "data", None)
+                if data is None:
+                    continue
+                if isinstance(data, str):
+                    data = base64.b64decode(data)
+                suffix = mimetypes.guess_extension(mime_type) or ".png"
+                with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp_file:
+                    path = tmp_file.name
+                with Path(path).open("wb") as f:
+                    f.write(data)
+                paths.append(path)
+        if not paths:
+            UserMessage("Gemini image generation returned no images.", raise_with=ValueError)
+        self._value = paths
+
+
+class GeminiImageEngine(Engine):
+    def __init__(self, api_key: str | None = None, model: str | None = None):
+        super().__init__()
+        self.config = SYMAI_CONFIG
+        self.api_key = self.config.get("DRAWING_ENGINE_API_KEY") if api_key is None else api_key
+        self.model = self.config.get("DRAWING_ENGINE_MODEL") if model is None else model
+        self.name = self.__class__.__name__
+        self.client = genai.Client(api_key=self.api_key)
+
+    def id(self) -> str:
+        cfg_model = self.config.get("DRAWING_ENGINE_MODEL")
+        if cfg_model and cfg_model.startswith(("gemini-2.5-flash-image", "gemini-3-pro-image-preview")):
+            return "drawing"
+        return super().id()
+
+    def command(self, *args, **kwargs):
+        super().command(*args, **kwargs)
+        if "DRAWING_ENGINE_API_KEY" in kwargs:
+            self.api_key = kwargs["DRAWING_ENGINE_API_KEY"]
+            self.client = genai.Client(api_key=self.api_key)
+        if "DRAWING_ENGINE_MODEL" in kwargs:
+            self.model = kwargs["DRAWING_ENGINE_MODEL"]
+
+    def prepare(self, argument):
+        argument.prop.prepared_input = str(argument.prop.processed_input)
+
+    def forward(self, argument):
+        prompt = argument.prop.prepared_input
+        kwargs = argument.kwargs
+        model = kwargs.get("model", self.model)
+        operation = kwargs.get("operation")
+
+        if operation != "create":
+            UserMessage(f"Unknown operation: {operation}", raise_with=ValueError)
+
+        response_modalities = kwargs.get("response_modalities", ["IMAGE"])
+        config = kwargs.get("config")
+        if config is None:
+            config = types.GenerateContentConfig(response_modalities=response_modalities)
+
+        except_remedy = kwargs.get("except_remedy", None)
+        try:
+            res = self.client.models.generate_content(
+                model=model,
+                contents=prompt,
+                config=config,
+            )
+        except Exception as e:
+            if except_remedy is None:
+                raise
+            res = except_remedy(self, e, None, argument)
+
+        metadata = {}
+        result = GeminiImageResult(res)
+        return [result], metadata

symai/backend/engines/embedding/engine_openai.py

@@ -20,25 +20,28 @@ class EmbeddingEngine(Engine, OpenAIMixin):
         logger = logging.getLogger("openai")
         logger.setLevel(logging.WARNING)
         self.config = SYMAI_CONFIG
+        self._api_key = api_key or self.config.get("EMBEDDING_ENGINE_API_KEY")
+        self._model = model or self.config.get("EMBEDDING_ENGINE_MODEL")
         if self.id() != "embedding":
             return  # do not initialize if not embedding; avoids conflict with llama.cpp check in EngineRepository.register_from_package
-        openai.api_key = self.config["EMBEDDING_ENGINE_API_KEY"] if api_key is None else api_key
-        self.model = self.config["EMBEDDING_ENGINE_MODEL"] if model is None else model
+        # Use openai client instance (required for openai 1.0+)
+        self._client = openai.OpenAI(api_key=self._api_key)
+        self.model = self._model
         self.max_tokens = self.api_max_context_tokens()
         self.embedding_dim = self.api_embedding_dims()
         self.name = self.__class__.__name__
 
     def id(self) -> str:
-        if self.config.get("EMBEDDING_ENGINE_API_KEY") and self.config[
-            "EMBEDDING_ENGINE_MODEL"
-        ].startswith("text-embedding"):
+        # Check stored params (from constructor or config)
+        if self._api_key and self._model and self._model.startswith("text-embedding"):
             return "embedding"
         return super().id()  # default to unregistered
 
     def command(self, *args, **kwargs):
         super().command(*args, **kwargs)
         if "EMBEDDING_ENGINE_API_KEY" in kwargs:
-            openai.api_key = kwargs["EMBEDDING_ENGINE_API_KEY"]
+            self._api_key = kwargs["EMBEDDING_ENGINE_API_KEY"]
+            self._client = openai.OpenAI(api_key=self._api_key)
         if "EMBEDDING_ENGINE_MODEL" in kwargs:
             self.model = kwargs["EMBEDDING_ENGINE_MODEL"]
 
@@ -52,11 +55,11 @@ class EmbeddingEngine(Engine, OpenAIMixin):
         new_dim = kwargs.get("new_dim")
 
         try:
-            res = openai.embeddings.create(model=self.model, input=inp)
+            res = self._client.embeddings.create(model=self.model, input=inp)
         except Exception as e:
             if except_remedy is None:
                 raise e
-            callback = openai.embeddings.create
+            callback = self._client.embeddings.create
             res = except_remedy(e, inp, callback, self, *args, **kwargs)
 
         if new_dim:

symai/backend/engines/neurosymbolic/__init__.py

@@ -12,6 +12,8 @@ from ...mixin import (
     OPENAI_CHAT_MODELS,
     OPENAI_REASONING_MODELS,
     OPENAI_RESPONSES_MODELS,
+    OPENROUTER_CHAT_MODELS,
+    OPENROUTER_REASONING_MODELS,
 )
 from .engine_anthropic_claudeX_chat import ClaudeXChatEngine
 from .engine_anthropic_claudeX_reasoning import ClaudeXReasoningEngine
@@ -19,6 +21,7 @@ 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_openrouter import OpenRouterEngine
 from .engine_openai_gptX_chat import GPTXChatEngine
 from .engine_openai_gptX_reasoning import GPTXReasoningEngine
 from .engine_openai_responses import OpenAIResponsesEngine
@@ -36,6 +39,8 @@ ENGINE_MAPPING = {
     **dict.fromkeys(OPENAI_RESPONSES_MODELS, OpenAIResponsesEngine),
     **dict.fromkeys(GROQ_CHAT_MODELS, GroqEngine),
     **dict.fromkeys(GROQ_REASONING_MODELS, GroqEngine),
+    **dict.fromkeys(OPENROUTER_CHAT_MODELS, OpenRouterEngine),
+    **dict.fromkeys(OPENROUTER_REASONING_MODELS, OpenRouterEngine),
 }
 
 __all__ = [
@@ -53,6 +58,8 @@ __all__ = [
     "OPENAI_CHAT_MODELS",
     "OPENAI_REASONING_MODELS",
     "OPENAI_RESPONSES_MODELS",
+    "OPENROUTER_CHAT_MODELS",
+    "OPENROUTER_REASONING_MODELS",
     "ClaudeXChatEngine",
     "ClaudeXReasoningEngine",
     "DeepSeekXReasoningEngine",
@@ -60,5 +67,6 @@ __all__ = [
     "GPTXReasoningEngine",
     "GeminiXReasoningEngine",
     "GroqEngine",
+    "OpenRouterEngine",
     "OpenAIResponsesEngine",
 ]

symai/backend/engines/neurosymbolic/engine_anthropic_claudeX_chat.py

@@ -64,6 +64,7 @@ class ClaudeXChatEngine(Engine, AnthropicMixin):
                 and "4-0" not in self.config.get("NEUROSYMBOLIC_ENGINE_MODEL")
                 and "4-1" not in self.config.get("NEUROSYMBOLIC_ENGINE_MODEL")
                 and "4-5" not in self.config.get("NEUROSYMBOLIC_ENGINE_MODEL")
+                and "4-6" not in self.config.get("NEUROSYMBOLIC_ENGINE_MODEL")
             )
         ):
             return "neurosymbolic"

symai/backend/engines/neurosymbolic/engine_anthropic_claudeX_reasoning.py

@@ -66,6 +66,7 @@ class ClaudeXReasoningEngine(Engine, AnthropicMixin):
                 or "4-0" in self.config.get("NEUROSYMBOLIC_ENGINE_MODEL")
                 or "4-1" in self.config.get("NEUROSYMBOLIC_ENGINE_MODEL")
                 or "4-5" in self.config.get("NEUROSYMBOLIC_ENGINE_MODEL")
+                or "4-6" in self.config.get("NEUROSYMBOLIC_ENGINE_MODEL")
             )
         ):
             return "neurosymbolic"
@@ -348,9 +349,48 @@ class ClaudeXReasoningEngine(Engine, AnthropicMixin):
 
         return {"role": "user", "content": user_text}
 
+    def _build_output_config(self, response_format):
+        if response_format is None:
+            return NOT_GIVEN
+
+        if response_format["type"] == "json_schema":
+            schema = response_format.get("schema")
+            if schema is None and response_format.get("json_schema") is not None:
+                schema = response_format["json_schema"].get("schema", response_format["json_schema"])
+            if schema is None:
+                return NOT_GIVEN
+            return {"format": {"type": "json_schema", "schema": schema}}
+
+        if response_format["type"] == "json_object":
+            schema = response_format.get("schema")
+            if schema is None:
+                return NOT_GIVEN
+            return {"format": {"type": "json_schema", "schema": schema}}
+
+        return NOT_GIVEN
+
     def _prepare_request_payload(self, argument):
         kwargs = argument.kwargs
         model = kwargs.get("model", self.model)
+        long_context_1m = bool(kwargs.get("long_context_1m", False))
+        use_long_context_1m = long_context_1m and self.supports_long_context_1m(model)
+        effective_context_tokens = self.api_max_context_tokens(model=model)
+        if effective_context_tokens is None:
+            effective_context_tokens = 200_000
+        if use_long_context_1m:
+            effective_context_tokens = self.api_max_context_tokens(
+                long_context_1m=True, model=model
+            )
+        if long_context_1m and not use_long_context_1m:
+            UserMessage(
+                "long_context_1m is only supported for claude-opus-4-6 and claude-sonnet-4-5; "
+                f"falling back to {effective_context_tokens} token context."
+            )
+
+        extra_headers = None
+        if use_long_context_1m:
+            extra_headers = {"anthropic-beta": self.long_context_beta_header()}
+
         stop = kwargs.get("stop", NOT_GIVEN)
         temperature = kwargs.get("temperature", 1)
         thinking_arg = kwargs.get("thinking", NOT_GIVEN)
@@ -368,6 +408,8 @@ class ClaudeXReasoningEngine(Engine, AnthropicMixin):
         tool_choice = kwargs.get("tool_choice", NOT_GIVEN)
         metadata_anthropic = kwargs.get("metadata", NOT_GIVEN)
         max_tokens = kwargs.get("max_tokens", self.max_response_tokens)
+        response_format = kwargs.get("response_format", argument.prop.response_format)
+        output_config = self._build_output_config(response_format)
 
         if stop != NOT_GIVEN and not isinstance(stop, list):
             stop = [stop]
@@ -377,7 +419,7 @@ class ClaudeXReasoningEngine(Engine, AnthropicMixin):
         if stop != NOT_GIVEN:
             stop = [r"{s}" for s in stop]
 
-        return {
+        payload = {
             "model": model,
             "max_tokens": max_tokens,
             "stop_sequences": stop,
@@ -389,7 +431,12 @@ class ClaudeXReasoningEngine(Engine, AnthropicMixin):
             "metadata": metadata_anthropic,
             "tools": tools,
             "tool_choice": tool_choice,
+            "output_config": output_config,
         }
+        if extra_headers is not None:
+            payload["extra_headers"] = extra_headers
+
+        return payload
 
     def _collect_response(self, res):
         if isinstance(res, list):

symai/backend/engines/neurosymbolic/engine_cerebras.py

@@ -16,6 +16,7 @@ logging.getLogger("requests").setLevel(logging.ERROR)
 logging.getLogger("urllib").setLevel(logging.ERROR)
 logging.getLogger("httpx").setLevel(logging.ERROR)
 logging.getLogger("httpcore").setLevel(logging.ERROR)
+logging.getLogger("hpack").setLevel(logging.ERROR)
 
 
 _NON_VERBOSE_OUTPUT = (

symai/backend/engines/neurosymbolic/engine_google_geminiX_reasoning.py

@@ -580,12 +580,25 @@ class GeminiXReasoningEngine(Engine, GoogleMixin):
     def _prepare_request_payload(self, argument):
         kwargs = argument.kwargs
 
+        stop_sequences = kwargs.get("stop")
+        if stop_sequences:
+            if isinstance(stop_sequences, str):
+                stop_sequences = [stop_sequences]
+            elif not isinstance(stop_sequences, list):
+                stop_sequences = None
+        else:
+            stop_sequences = None
+        if isinstance(stop_sequences, list):
+            stop_sequences = [seq for seq in stop_sequences if seq]
+            if not stop_sequences:
+                stop_sequences = None
+
         payload = {
             "max_output_tokens": kwargs.get("max_tokens", self.max_response_tokens),
             "temperature": kwargs.get("temperature", 1.0),
             "top_p": kwargs.get("top_p", 0.95),
             "top_k": kwargs.get("top_k", 40),
-            "stop_sequences": kwargs.get("stop", None),
+            "stop_sequences": stop_sequences,
             "stream": kwargs.get("stream", False),
         }