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

symai/backend/engines/neurosymbolic/engine_openrouter.py

@@ -0,0 +1,294 @@
+import json
+import logging
+from copy import deepcopy
+
+import openai
+
+from ....components import SelfPrompt
+from ....core_ext import retry
+from ....utils import UserMessage
+from ...base import Engine
+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 OpenRouterEngine(Engine):
+    def __init__(self, api_key: str | None = None, model: str | None = None):
+        super().__init__()
+        self.config = deepcopy(SYMAI_CONFIG)
+        # In case we use EngineRepository.register to inject the api_key and model => dynamically change the engine at runtime
+        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  # 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"]
+        self.seed = None
+        self.name = self.__class__.__name__
+        self._last_prompt_tokens = None
+        self._last_messages = None
+
+        try:
+            self.client = openai.OpenAI(
+                api_key=openai.api_key, base_url="https://openrouter.ai/api/v1"
+            )
+        except Exception as exc:
+            UserMessage(
+                f"Failed to initialize OpenRouter client. Please check your OpenAI library version. Caused by: {exc}",
+                raise_with=ValueError,
+            )
+
+    def id(self) -> str:
+        model_name = self.config.get("NEUROSYMBOLIC_ENGINE_MODEL")
+        if model_name and model_name.startswith("openrouter"):
+            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.model = kwargs["NEUROSYMBOLIC_ENGINE_MODEL"]
+        if "seed" in kwargs:
+            self.seed = kwargs["seed"]
+
+    def compute_required_tokens(self, messages):
+        if self._last_prompt_tokens is not None and self._last_messages == messages:
+            return self._last_prompt_tokens
+        UserMessage(
+            "Token counting not implemented for this engine.", raise_with=NotImplementedError
+        )
+        return 0
+
+    def compute_remaining_tokens(self, _prompts: list) -> int:
+        UserMessage(
+            "Token counting not implemented for this engine.", raise_with=NotImplementedError
+        )
+
+    def _handle_prefix(self, model_name: str) -> str:
+        """Handle prefix for model name."""
+        return model_name.replace("openrouter:", "")
+
+    def _extract_thinking_content(self, output: list[str]) -> tuple[str | None, list[str]]:
+        """Extract thinking content from textual output using <think>...</think> tags if present."""
+        if not output or not output[0]:
+            return None, output
+
+        content = output[0]
+        start = content.find("<think>")
+        if start == -1:
+            return None, output
+
+        end = content.find("</think>", start + 7)
+        if end == -1:
+            return None, output
+
+        thinking_content = content[start + 7 : end].strip() or None
+        cleaned_content = (content[:start] + content[end + 8 :]).strip()
+        cleaned_output = [cleaned_content, *output[1:]]
+
+        return thinking_content, cleaned_output
+
+    # cumulative wait time is < 30s
+    @retry(tries=8, delay=0.5, backoff=1.5, max_delay=5, jitter=(0, 0.5))
+    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.chat.completions.create(**payload)
+        except Exception as exc:
+            if openai.api_key is None or openai.api_key == "":
+                msg = (
+                    "OpenRouter API key is not set. Please set it in the config file or "
+                    "pass it as an argument to the command method."
+                )
+                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.chat.completions.create
+            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, exc, callback, argument)
+            else:
+                UserMessage(f"Error during generation. Caused by: {exc}", raise_with=ValueError)
+
+        prompt_tokens = getattr(res.usage, "prompt_tokens", None)
+        if prompt_tokens is None:
+            prompt_tokens = getattr(res.usage, "input_tokens", None)
+        self._last_prompt_tokens = prompt_tokens
+        self._last_messages = messages
+
+        metadata = {"raw_output": res}
+        if payload.get("tools"):
+            metadata = self._process_function_calls(res, metadata)
+
+        output = [r.message.content for r in res.choices]
+        thinking, output = self._extract_thinking_content(output)
+        if thinking:
+            metadata["thinking"] = thinking
+
+        return output, metadata
+
+    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
+        self._validate_response_format(argument)
+
+        system = self._build_system_message(argument)
+        user_content = self._build_user_content(argument)
+        user_prompt = {"role": "user", "content": user_content}
+        system, user_prompt = self._apply_self_prompt_if_needed(argument, system, user_prompt)
+
+        argument.prop.prepared_input = [
+            {"role": "system", "content": system},
+            user_prompt,
+        ]
+
+    def _validate_response_format(self, argument) -> None:
+        if argument.prop.response_format:
+            response_format = argument.prop.response_format
+            assert response_format.get("type") is not None, (
+                'Expected format `{ "type": "json_object" }`! We are using the OpenAI compatible '
+                "API for OpenRouter."
+            )
+
+    def _build_system_message(self, argument) -> str:
+        system: str = ""
+        if argument.prop.suppress_verbose_output:
+            system += _NON_VERBOSE_OUTPUT
+        if system:
+            system = f"{system}\n"
+
+        ref = argument.prop.instance
+        static_ctxt, dyn_ctxt = ref.global_context
+        if len(static_ctxt) > 0:
+            system += f"<STATIC CONTEXT/>\n{static_ctxt}\n\n"
+
+        if len(dyn_ctxt) > 0:
+            system += f"<DYNAMIC CONTEXT/>\n{dyn_ctxt}\n\n"
+
+        if argument.prop.payload:
+            system += f"<ADDITIONAL CONTEXT/>\n{argument.prop.payload!s}\n\n"
+
+        examples = argument.prop.examples
+        if examples and len(examples) > 0:
+            system += f"<EXAMPLES/>\n{examples!s}\n\n"
+
+        if argument.prop.prompt is not None and len(argument.prop.prompt) > 0:
+            val = str(argument.prop.prompt)
+            system += f"<INSTRUCTION/>\n{val}\n\n"
+
+        if argument.prop.template_suffix:
+            system += (
+                " You will only generate content for the placeholder "
+                f"`{argument.prop.template_suffix!s}` following the instructions and the provided context "
+                "information.\n\n"
+            )
+
+        return system
+
+    def _build_user_content(self, argument) -> str:
+        return str(argument.prop.processed_input)
+
+    def _apply_self_prompt_if_needed(self, argument, system, user_prompt):
+        if argument.prop.instance._kwargs.get("self_prompt", False) or argument.prop.self_prompt:
+            self_prompter = SelfPrompt()
+            res = self_prompter({"user": user_prompt["content"], "system": system})
+            if res is None:
+                UserMessage("Self-prompting failed!", raise_with=ValueError)
+            return res["system"], {"role": "user", "content": res["user"]}
+        return system, user_prompt
+
+    def _process_function_calls(self, res, metadata):
+        hit = False
+        if (
+            hasattr(res, "choices")
+            and res.choices
+            and hasattr(res.choices[0], "message")
+            and res.choices[0].message
+            and hasattr(res.choices[0].message, "tool_calls")
+            and res.choices[0].message.tool_calls
+        ):
+            for tool_call in res.choices[0].message.tool_calls:
+                if hasattr(tool_call, "function") and tool_call.function:
+                    if hit:
+                        UserMessage(
+                            "Multiple function calls detected in the response but only the first one will be processed."
+                        )
+                        break
+                    try:
+                        args_dict = json.loads(tool_call.function.arguments)
+                    except json.JSONDecodeError:
+                        args_dict = {}
+                    metadata["function_call"] = {
+                        "name": tool_call.function.name,
+                        "arguments": args_dict,
+                    }
+                    hit = True
+        return metadata
+
+    # TODO: requires updates for reasoning
+    def _prepare_request_payload(self, messages, argument):
+        kwargs = argument.kwargs
+        max_tokens = kwargs.get("max_tokens")
+        if max_tokens is None:
+            max_tokens = kwargs.get("max_completion_tokens")
+        return {
+            "messages": messages,
+            "model": self._handle_prefix(kwargs.get("model", self.model)),
+            "seed": kwargs.get("seed", self.seed),
+            "max_tokens": max_tokens,
+            "stop": kwargs.get("stop"),
+            "temperature": kwargs.get("temperature", 1),
+            "frequency_penalty": kwargs.get("frequency_penalty", 0),
+            "presence_penalty": kwargs.get("presence_penalty", 0),
+            "top_p": kwargs.get("top_p", 1),
+            "n": kwargs.get("n", 1),
+            "tools": kwargs.get("tools"),
+            "tool_choice": kwargs.get("tool_choice"),
+            "response_format": kwargs.get("response_format"),
+            "stream": kwargs.get("stream", False),
+        }

symai/backend/mixin/__init__.py

@@ -11,6 +11,8 @@ 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
+from .openrouter import SUPPORTED_CHAT_MODELS as OPENROUTER_CHAT_MODELS
+from .openrouter import SUPPORTED_REASONING_MODELS as OPENROUTER_REASONING_MODELS
 
 __all__ = [
     "ANTHROPIC_CHAT_MODELS",
@@ -26,4 +28,6 @@ __all__ = [
     "OPENAI_CHAT_MODELS",
     "OPENAI_REASONING_MODELS",
     "OPENAI_RESPONSES_MODELS",
+    "OPENROUTER_CHAT_MODELS",
+    "OPENROUTER_REASONING_MODELS",
 ]

symai/backend/mixin/openrouter.py

@@ -0,0 +1,2 @@
+SUPPORTED_CHAT_MODELS = ["openrouter:moonshotai/kimi-k2.5"]
+SUPPORTED_REASONING_MODELS = []

symai/components.py

@@ -1229,6 +1229,7 @@ class MetadataTracker(Expression):
             and frame.f_code.co_name == "forward"
             and "self" in frame.f_locals
             and isinstance(frame.f_locals["self"], Engine)
+            and arg is not None  # Ensure arg is not None to avoid unpacking error on exceptions
         ):
             _, metadata = arg  # arg contains return value on 'return' event
             engine_name = frame.f_locals["self"].__class__.__name__
@@ -1350,6 +1351,116 @@ class MetadataTracker(Expression):
                     token_details[(engine_name, model_name)]["completion_breakdown"][
                         "reasoning_tokens"
                     ] += 0
+                elif engine_name in ("ClaudeXChatEngine", "ClaudeXReasoningEngine"):
+                    raw_output = metadata["raw_output"]
+                    usage = self._extract_claude_usage(raw_output)
+                    if usage is None:
+                        # Skip if we can't extract usage (shouldn't happen normally)
+                        logger.warning(f"Could not extract usage from {engine_name} response.")
+                        token_details[(engine_name, model_name)]["usage"]["total_calls"] += 1
+                        token_details[(engine_name, model_name)]["prompt_breakdown"][
+                            "cached_tokens"
+                        ] += 0
+                        token_details[(engine_name, model_name)]["completion_breakdown"][
+                            "reasoning_tokens"
+                        ] += 0
+                        continue
+                    input_tokens = getattr(usage, "input_tokens", 0) or 0
+                    output_tokens = getattr(usage, "output_tokens", 0) or 0
+                    token_details[(engine_name, model_name)]["usage"]["prompt_tokens"] += (
+                        input_tokens
+                    )
+                    token_details[(engine_name, model_name)]["usage"]["completion_tokens"] += (
+                        output_tokens
+                    )
+                    # Calculate total tokens
+                    total = input_tokens + output_tokens
+                    token_details[(engine_name, model_name)]["usage"]["total_tokens"] += total
+                    token_details[(engine_name, model_name)]["usage"]["total_calls"] += 1
+                    # Track cache tokens if available
+                    cache_creation = getattr(usage, "cache_creation_input_tokens", 0) or 0
+                    cache_read = getattr(usage, "cache_read_input_tokens", 0) or 0
+                    token_details[(engine_name, model_name)]["prompt_breakdown"][
+                        "cache_creation_tokens"
+                    ] += cache_creation
+                    token_details[(engine_name, model_name)]["prompt_breakdown"][
+                        "cache_read_tokens"
+                    ] += cache_read
+                    # For backward compatibility, also track as cached_tokens
+                    token_details[(engine_name, model_name)]["prompt_breakdown"][
+                        "cached_tokens"
+                    ] += cache_read
+                    # Track reasoning/thinking tokens for ClaudeXReasoningEngine
+                    if engine_name == "ClaudeXReasoningEngine":
+                        thinking_output = metadata.get("thinking", "")
+                        # Store thinking content if available
+                        if thinking_output:
+                            if "thinking_content" not in token_details[(engine_name, model_name)]:
+                                token_details[(engine_name, model_name)]["thinking_content"] = []
+                            token_details[(engine_name, model_name)]["thinking_content"].append(
+                                thinking_output
+                            )
+                    # Note: Anthropic doesn't break down reasoning tokens separately in usage,
+                    # but extended thinking is included in output_tokens
+                    token_details[(engine_name, model_name)]["completion_breakdown"][
+                        "reasoning_tokens"
+                    ] += 0
+                elif engine_name == "GeminiXReasoningEngine":
+                    usage = metadata["raw_output"].usage_metadata
+                    token_details[(engine_name, model_name)]["usage"]["prompt_tokens"] += (
+                        usage.prompt_token_count
+                    )
+                    token_details[(engine_name, model_name)]["usage"]["completion_tokens"] += (
+                        usage.candidates_token_count
+                    )
+                    token_details[(engine_name, model_name)]["usage"]["total_tokens"] += (
+                        usage.total_token_count
+                    )
+                    token_details[(engine_name, model_name)]["usage"]["total_calls"] += 1
+                    # Track cache tokens if available
+                    cache_read = getattr(usage, "cached_content_token_count", 0) or 0
+                    token_details[(engine_name, model_name)]["prompt_breakdown"][
+                        "cached_tokens"
+                    ] += cache_read
+                    # Track thinking content if available
+                    thinking_output = metadata.get("thinking", "")
+                    if thinking_output:
+                        if "thinking_content" not in token_details[(engine_name, model_name)]:
+                            token_details[(engine_name, model_name)]["thinking_content"] = []
+                        token_details[(engine_name, model_name)]["thinking_content"].append(
+                            thinking_output
+                        )
+                    # Note: Gemini reasoning tokens are part of candidates_token_count
+                    token_details[(engine_name, model_name)]["completion_breakdown"][
+                        "reasoning_tokens"
+                    ] += 0
+                elif engine_name == "DeepSeekXReasoningEngine":
+                    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
+                    # Track thinking content if available
+                    thinking_output = metadata.get("thinking", "")
+                    if thinking_output:
+                        if "thinking_content" not in token_details[(engine_name, model_name)]:
+                            token_details[(engine_name, model_name)]["thinking_content"] = []
+                        token_details[(engine_name, model_name)]["thinking_content"].append(
+                            thinking_output
+                        )
+                    # Note: DeepSeek reasoning tokens might be in completion_tokens_details
+                    reasoning_tokens = 0
+                    if hasattr(usage, "completion_tokens_details") and usage.completion_tokens_details:
+                        reasoning_tokens = getattr(usage.completion_tokens_details, "reasoning_tokens", 0) or 0
+                    token_details[(engine_name, model_name)]["completion_breakdown"][
+                        "reasoning_tokens"
+                    ] += reasoning_tokens
                 else:
                     logger.warning(f"Tracking {engine_name} is not supported.")
                     continue
@@ -1361,8 +1472,60 @@ class MetadataTracker(Expression):
         # Convert to normal dict
         return {**token_details}
 
+    def _extract_claude_usage(self, raw_output):
+        """Extract usage information from Claude response (handles both streaming and non-streaming).
+
+        For non-streaming responses, raw_output is a Message object with a .usage attribute.
+        For streaming responses, raw_output is a list of stream events. Usage info is in:
+        - RawMessageStartEvent.message.usage (input_tokens)
+        - RawMessageDeltaEvent.usage (output_tokens)
+        """
+        # Non-streaming: raw_output is a Message with .usage
+        if hasattr(raw_output, "usage"):
+            return raw_output.usage
+
+        # Streaming: raw_output is a list of events
+        if isinstance(raw_output, list):
+            # Accumulate usage from stream events
+            input_tokens = 0
+            output_tokens = 0
+            cache_creation = 0
+            cache_read = 0
+
+            for event in raw_output:
+                # RawMessageStartEvent contains initial usage with input_tokens
+                if hasattr(event, "message") and hasattr(event.message, "usage"):
+                    msg_usage = event.message.usage
+                    input_tokens += getattr(msg_usage, "input_tokens", 0) or 0
+                    cache_creation += getattr(msg_usage, "cache_creation_input_tokens", 0) or 0
+                    cache_read += getattr(msg_usage, "cache_read_input_tokens", 0) or 0
+                # RawMessageDeltaEvent contains usage with output_tokens
+                elif hasattr(event, "usage") and event.usage is not None:
+                    evt_usage = event.usage
+                    output_tokens += getattr(evt_usage, "output_tokens", 0) or 0
+
+            # Create a simple object-like dict to hold usage (using Box for attribute access)
+            return Box({
+                "input_tokens": input_tokens,
+                "output_tokens": output_tokens,
+                "cache_creation_input_tokens": cache_creation,
+                "cache_read_input_tokens": cache_read,
+            })
+
+        return None
+
     def _can_accumulate_engine(self, engine_name: str) -> bool:
-        supported_engines = ("GPTXChatEngine", "GPTXReasoningEngine", "GPTXSearchEngine")
+        supported_engines = (
+            "GPTXChatEngine",
+            "GPTXReasoningEngine",
+            "GPTXSearchEngine",
+            "ClaudeXChatEngine",
+            "ClaudeXReasoningEngine",
+            "GeminiXReasoningEngine",
+            "DeepSeekXReasoningEngine",
+            "GroqEngine",
+            "CerebrasEngine",
+        )
         return engine_name in supported_engines
 
     def _track_parallel_usage_items(self, token_details, engine_name, metadata):
@@ -1388,21 +1551,48 @@ class MetadataTracker(Expression):
 
         metadata_raw_output = metadata["raw_output"]
         accumulated_raw_output = accumulated["raw_output"]
-        if not hasattr(metadata_raw_output, "usage") or not hasattr(
-            accumulated_raw_output, "usage"
-        ):
-            return
 
-        current_usage = metadata_raw_output.usage
-        accumulated_usage = accumulated_raw_output.usage
+        # Handle both OpenAI/Anthropic-style (usage) and Gemini-style (usage_metadata)
+        current_usage = getattr(metadata_raw_output, "usage", None) or getattr(
+            metadata_raw_output, "usage_metadata", None
+        )
+        accumulated_usage = getattr(accumulated_raw_output, "usage", None) or getattr(
+            accumulated_raw_output, "usage_metadata", None
+        )
 
-        for attr in ["completion_tokens", "prompt_tokens", "total_tokens"]:
+        if not current_usage or not accumulated_usage:
+            return
+
+        # Handle both OpenAI-style (completion_tokens, prompt_tokens),
+        # Anthropic-style (output_tokens, input_tokens),
+        # and Gemini-style (candidates_token_count, prompt_token_count) fields
+        token_attrs = [
+            "completion_tokens",
+            "prompt_tokens",
+            "total_tokens",
+            "input_tokens",
+            "output_tokens",
+            "candidates_token_count",
+            "prompt_token_count",
+            "total_token_count",
+        ]
+        for attr in token_attrs:
             if hasattr(current_usage, attr) and hasattr(accumulated_usage, attr):
-                setattr(
-                    accumulated_usage,
-                    attr,
-                    getattr(accumulated_usage, attr) + getattr(current_usage, attr),
-                )
+                current_val = getattr(current_usage, attr) or 0
+                accumulated_val = getattr(accumulated_usage, attr) or 0
+                setattr(accumulated_usage, attr, accumulated_val + current_val)
+
+        # Handle Anthropic cache tokens and Gemini cached tokens
+        cache_attrs = [
+            "cache_creation_input_tokens",
+            "cache_read_input_tokens",
+            "cached_content_token_count",
+        ]
+        for attr in cache_attrs:
+            if hasattr(current_usage, attr) and hasattr(accumulated_usage, attr):
+                current_val = getattr(current_usage, attr) or 0
+                accumulated_val = getattr(accumulated_usage, attr) or 0
+                setattr(accumulated_usage, attr, accumulated_val + current_val)
 
         for detail_attr in ["completion_tokens_details", "prompt_tokens_details"]:
             if not hasattr(current_usage, detail_attr) or not hasattr(

symai/extended/interfaces/nanobanana.py

@@ -0,0 +1,23 @@
+from ... import core
+from ...backend.engines.drawing.engine_gemini_image import GeminiImageResult
+from ...symbol import Expression
+
+
+class nanobanana(Expression):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.name = self.__class__.__name__
+
+    def __call__(
+        self,
+        prompt: str | None = None,
+        operation: str = "create",
+        **kwargs,
+    ) -> list:
+        prompt = self._to_symbol(prompt)
+
+        @core.draw(operation=operation, **kwargs)
+        def _func(_) -> GeminiImageResult:
+            pass
+
+        return _func(prompt).value

symai/interfaces.py

@@ -42,6 +42,8 @@ def _add_symbolic_interface(mapping):
 def _resolve_drawing_interface_name(drawing_engine_model):
     if drawing_engine_model.startswith("flux"):
         return "flux"
+    if drawing_engine_model.startswith(("gemini-2.5-flash-image", "gemini-3-pro-image-preview")):
+        return "nanobanana"
     if drawing_engine_model.startswith("dall-e-"):
         return "dall_e"
     if drawing_engine_model.startswith("gpt-image-"):

symai/ops/primitives.py

@@ -745,12 +745,6 @@ class OperatorPrimitives(Primitive):
         Returns:
             Symbol: A new symbol with the result of the OR operation.
         """
-        # Exclude the evaluation for the Aggregator class; keep import local to avoid ops.primitives <-> collect.stats cycle.
-        from ..collect.stats import Aggregator  # noqa
-
-        if isinstance(other, Aggregator):
-            return NotImplemented
-
         result = self.__try_type_specific_func(
             other, lambda self, other: self.value | other.value, op="|"
         )
@@ -777,12 +771,6 @@ class OperatorPrimitives(Primitive):
         Returns:
             Symbol: A new Symbol object with the concatenated value.
         """
-        # Exclude the evaluation for the Aggregator class; keep import local to avoid ops.primitives <-> collect.stats cycle.
-        from ..collect.stats import Aggregator  # noqa
-
-        if isinstance(other, Aggregator):
-            return NotImplemented
-
         result = self.__try_type_specific_func(
             other, lambda self, other: self.value | other.value, op="|"
         )
@@ -811,12 +799,6 @@ class OperatorPrimitives(Primitive):
         Returns:
             Symbol: A new Symbol object with the concatenated value.
         """
-        # Exclude the evaluation for the Aggregator class; keep import local to avoid ops.primitives <-> collect.stats cycle.
-        from ..collect.stats import Aggregator  # noqa
-
-        if isinstance(other, Aggregator):
-            return NotImplemented
-
         result = self.__try_type_specific_func(
             other, lambda self, other: self.value | other.value, op="|="
         )

symai/shellsv.py

@@ -1070,14 +1070,9 @@ def run(auto_query_on_error=False, conversation_style=None, verbose=False):
         ) = styles_
         state.use_styles = True
 
-    if SYMSH_CONFIG["show-splash-screen"]:
+    if SYMSH_CONFIG.get("show-splash-screen", True):
         show_intro_menu()
-        # set show splash screen to false
-        SYMSH_CONFIG["show-splash-screen"] = False
-        # save config
-        _config_path = HOME_PATH / "symsh.config.json"
-        with _config_path.open("w") as f:
-            json.dump(SYMSH_CONFIG, f, indent=4)
+
     if "plugin_prefix" not in SYMSH_CONFIG:
         SYMSH_CONFIG["plugin_prefix"] = None