janito 2.2.0__py3-none-any.whl → 2.3.0__py3-none-any.whl

janito/providers/deepseek/provider.py

@@ -1,91 +1,91 @@
-from janito.llm.provider import LLMProvider
-from janito.llm.model import LLMModelInfo
-from janito.llm.auth import LLMAuthManager
-from janito.llm.driver_config import LLMDriverConfig
-from janito.drivers.openai.driver import OpenAIModelDriver
-from janito.tools import get_local_tools_adapter
-from janito.providers.registry import LLMProviderRegistry
-from .model_info import MODEL_SPECS
-from queue import Queue
-
-available = OpenAIModelDriver.available
-unavailable_reason = OpenAIModelDriver.unavailable_reason
-
-
-class DeepseekProvider(LLMProvider):
-    name = "deepseek"
-    maintainer = "Needs maintainer"
-    MODEL_SPECS = MODEL_SPECS
-    DEFAULT_MODEL = "deepseek-chat"  # Options: deepseek-chat, deepseek-reasoner
-
-    def __init__(
-        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
-    ):
-        if not self.available:
-            self._driver = None
-        else:
-            self.auth_manager = auth_manager or LLMAuthManager()
-            self._api_key = self.auth_manager.get_credentials(type(self).name)
-            self._tools_adapter = get_local_tools_adapter()
-            self._driver_config = config or LLMDriverConfig(model=None)
-            if not self._driver_config.model:
-                self._driver_config.model = self.DEFAULT_MODEL
-            if not self._driver_config.api_key:
-                self._driver_config.api_key = self._api_key
-            # Set DeepSeek public endpoint as default base_url if not provided
-            if not getattr(self._driver_config, "base_url", None):
-                self._driver_config.base_url = "https://api.deepseek.com/v1"
-            self.fill_missing_device_info(self._driver_config)
-            self._driver = None  # to be provided by factory/agent
-
-    @property
-    def driver(self) -> OpenAIModelDriver:
-        if not self.available:
-            raise ImportError(f"OpenAIProvider unavailable: {self.unavailable_reason}")
-        return self._driver
-
-    @property
-    def available(self):
-        return available
-
-    @property
-    def unavailable_reason(self):
-        return unavailable_reason
-
-    def create_driver(self):
-        """
-        Creates and returns a new OpenAIModelDriver instance with input/output queues.
-        """
-        driver = OpenAIModelDriver(
-            tools_adapter=self._tools_adapter, provider_name=self.name
-        )
-        driver.config = self._driver_config
-        # NOTE: The caller is responsible for calling driver.start() if background processing is needed.
-        return driver
-
-    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
-        from janito.llm.agent import LLMAgent
-
-        # Always create a new driver with the passed-in tools_adapter
-        if tools_adapter is None:
-            tools_adapter = get_local_tools_adapter()
-        # Should use new-style driver construction via queues/factory (handled elsewhere)
-        raise NotImplementedError(
-            "create_agent must be constructed via new factory using input/output queues and config."
-        )
-
-    @property
-    def model_name(self):
-        return self._driver_config.model
-
-    @property
-    def driver_config(self):
-        """Public, read-only access to the provider's LLMDriverConfig object."""
-        return self._driver_config
-
-    def execute_tool(self, tool_name: str, event_bus, *args, **kwargs):
-        self._tools_adapter.event_bus = event_bus
-        return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
-
-
-LLMProviderRegistry.register(DeepseekProvider.name, DeepseekProvider)
+from janito.llm.provider import LLMProvider
+from janito.llm.model import LLMModelInfo
+from janito.llm.auth import LLMAuthManager
+from janito.llm.driver_config import LLMDriverConfig
+from janito.drivers.openai.driver import OpenAIModelDriver
+from janito.tools import get_local_tools_adapter
+from janito.providers.registry import LLMProviderRegistry
+from .model_info import MODEL_SPECS
+from queue import Queue
+
+available = OpenAIModelDriver.available
+unavailable_reason = OpenAIModelDriver.unavailable_reason
+
+
+class DeepseekProvider(LLMProvider):
+    name = "deepseek"
+    maintainer = "Needs maintainer"
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = "deepseek-chat"  # Options: deepseek-chat, deepseek-reasoner
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        if not self.available:
+            self._driver = None
+        else:
+            self.auth_manager = auth_manager or LLMAuthManager()
+            self._api_key = self.auth_manager.get_credentials(type(self).name)
+            self._tools_adapter = get_local_tools_adapter()
+            self._driver_config = config or LLMDriverConfig(model=None)
+            if not self._driver_config.model:
+                self._driver_config.model = self.DEFAULT_MODEL
+            if not self._driver_config.api_key:
+                self._driver_config.api_key = self._api_key
+            # Set DeepSeek public endpoint as default base_url if not provided
+            if not getattr(self._driver_config, "base_url", None):
+                self._driver_config.base_url = "https://api.deepseek.com/v1"
+            self.fill_missing_device_info(self._driver_config)
+            self._driver = None  # to be provided by factory/agent
+
+    @property
+    def driver(self) -> OpenAIModelDriver:
+        if not self.available:
+            raise ImportError(f"OpenAIProvider unavailable: {self.unavailable_reason}")
+        return self._driver
+
+    @property
+    def available(self):
+        return available
+
+    @property
+    def unavailable_reason(self):
+        return unavailable_reason
+
+    def create_driver(self):
+        """
+        Creates and returns a new OpenAIModelDriver instance with input/output queues.
+        """
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.name
+        )
+        driver.config = self._driver_config
+        # NOTE: The caller is responsible for calling driver.start() if background processing is needed.
+        return driver
+
+    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
+        from janito.llm.agent import LLMAgent
+
+        # Always create a new driver with the passed-in tools_adapter
+        if tools_adapter is None:
+            tools_adapter = get_local_tools_adapter()
+        # Should use new-style driver construction via queues/factory (handled elsewhere)
+        raise NotImplementedError(
+            "create_agent must be constructed via new factory using input/output queues and config."
+        )
+
+    @property
+    def model_name(self):
+        return self._driver_config.model
+
+    @property
+    def driver_config(self):
+        """Public, read-only access to the provider's LLMDriverConfig object."""
+        return self._driver_config
+
+    def execute_tool(self, tool_name: str, event_bus, *args, **kwargs):
+        self._tools_adapter.event_bus = event_bus
+        return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
+
+
+LLMProviderRegistry.register(DeepseekProvider.name, DeepseekProvider)

janito/providers/google/model_info.py

@@ -1,40 +1,32 @@
 from janito.llm.model import LLMModelInfo
 
 MODEL_SPECS = {
-    "gemini-2.5-pro-preview-05-06": LLMModelInfo(
-        name="gemini-2.5-pro-preview-05-06",
-        context=131072,
-        max_input=131072,
-        max_cot="N/A",
-        max_response=32768,
-        thinking_supported=True,
-        default_temp=0.2,
+    "gemini-2.5-flash": LLMModelInfo(
+        name="gemini-2.5-flash",
+        other={"description": "Google Gemini 2.5 Flash (OpenAI-compatible endpoint)"},
         open="google",
-        driver="GoogleGenaiModelDriver",
-        other={"preview": True},
-    ),
-    "gemini-2.5-flash-preview-05-20": LLMModelInfo(
-        name="gemini-2.5-flash-preview-05-20",
-        context=1000000,
-        max_input=1000000,
-        max_cot="N/A",
-        max_response=65536,
+        driver="OpenAIModelDriver",
+        max_response=8192,
+        max_cot=24576,
         thinking_supported=True,
-        default_temp=0.2,
-        open="google",
-        driver="GoogleGenaiModelDriver",
-        other={"preview": True, "flash": True},
     ),
-    "gemini-2.5-flash-preview-04-17": LLMModelInfo(
-        name="gemini-2.5-flash-preview-04-17",
-        context=1000000,
-        max_input=1000000,
-        max_cot="N/A",
+        "gemini-2.5-pro": LLMModelInfo(
+        name="gemini-2.5-pro",
+        other={"description": "Google Gemini 2.5 Pro (OpenAI-compatible endpoint)"},
+        open="google",
+        driver="OpenAIModelDriver",
         max_response=65536,
+        max_cot=196608,
         thinking_supported=True,
-        default_temp=0.2,
+    ),
+    "gemini-2.5-flash-lite-preview-06-17": LLMModelInfo(
+        name="gemini-2.5-flash-lite-preview-06-17",
+        other={"description": "Google Gemini 2.5 Flash-Lite Preview (OpenAI-compatible endpoint)"},
         open="google",
-        driver="GoogleGenaiModelDriver",
-        other={"preview": True, "flash": True},
+        driver="OpenAIModelDriver",
+        max_response=64000,
+        max_cot=192000,
+        thinking_supported=True,
     ),
+    # Add more Gemini models as needed
 }

janito/providers/google/provider.py

@@ -2,64 +2,75 @@ from janito.llm.provider import LLMProvider
 from janito.llm.model import LLMModelInfo
 from janito.llm.auth import LLMAuthManager
 from janito.llm.driver_config import LLMDriverConfig
-from janito.drivers.google_genai.driver import GoogleGenaiModelDriver
-from janito.tools.adapters.local.adapter import LocalToolsAdapter
+from janito.drivers.openai.driver import OpenAIModelDriver
+from janito.tools import get_local_tools_adapter
 from janito.providers.registry import LLMProviderRegistry
+from queue import Queue
 
-from .model_info import MODEL_SPECS
-
-from janito.drivers.google_genai.driver import GoogleGenaiModelDriver
-
-available = GoogleGenaiModelDriver.available
-unavailable_reason = GoogleGenaiModelDriver.unavailable_reason
-maintainer = "Needs maintainer"
-
+# Import Google Gemini model specs (to be created or imported as needed)
+try:
+    from .model_info import MODEL_SPECS
+except ImportError:
+    MODEL_SPECS = {}
 
 class GoogleProvider(LLMProvider):
-    MODEL_SPECS = MODEL_SPECS
-    maintainer = "Needs maintainer"
-    """
-    Provider for Google LLMs via google-google.
-    Default model: 'gemini-2.5-pro-preview-05-06'.
-    """
     name = "google"
-    DEFAULT_MODEL = "gemini-2.5-flash-preview-04-17"
+    maintainer = "João Pinto <lamego.pinto@gmail.com>"
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = "gemini-2.5-flash"  # Default Gemini model
 
-    def __init__(self, config: LLMDriverConfig = None):
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
         if not self.available:
             self._driver = None
-            return
-        self._auth_manager = LLMAuthManager()
-        self._api_key = self._auth_manager.get_credentials(type(self).name)
-        self._tools_adapter = LocalToolsAdapter()
-        self._info = config or LLMDriverConfig(model=None)
-        if not self._info.model:
-            self._info.model = self.DEFAULT_MODEL
-        if not self._info.api_key:
-            self._info.api_key = self._api_key
-        self.fill_missing_device_info(self._info)
-        self._driver = GoogleGenaiModelDriver(tools_adapter=self._tools_adapter)
+        else:
+            self.auth_manager = auth_manager or LLMAuthManager()
+            self._api_key = self.auth_manager.get_credentials(type(self).name)
+            self._tools_adapter = get_local_tools_adapter()
+            self._driver_config = config or LLMDriverConfig(model=None)
+            # Only set default if model is not set by CLI/config
+            if not getattr(self._driver_config, 'model', None):
+                self._driver_config.model = self.DEFAULT_MODEL
+            if not self._driver_config.api_key:
+                self._driver_config.api_key = self._api_key
+            # Set the Gemini API endpoint for OpenAI compatibility
+            self._driver_config.base_url = "https://generativelanguage.googleapis.com/v1beta/openai/"
+            self.fill_missing_device_info(self._driver_config)
+            self._driver = None  # to be provided by factory/agent
 
     @property
-    def driver(self) -> GoogleGenaiModelDriver:
+    def driver(self) -> OpenAIModelDriver:
         if not self.available:
-            raise ImportError(f"GoogleProvider unavailable: {self.unavailable_reason}")
+            raise ImportError(f"GoogleOpenAIProvider unavailable: {self.unavailable_reason}")
         return self._driver
 
     @property
     def available(self):
-        return available
+        return OpenAIModelDriver.available
 
     @property
     def unavailable_reason(self):
-        return unavailable_reason
+        return OpenAIModelDriver.unavailable_reason
+
+    def create_driver(self):
+        """
+        Creates and returns a new OpenAIModelDriver instance configured for Gemini API.
+        """
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.name
+        )
+        driver.config = self._driver_config
+        return driver
 
-    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
-        from janito.llm.agent import LLMAgent
+    @property
+    def model_name(self):
+        return self._driver_config.model
 
-        # Always create a new driver with the passed-in tools_adapter
-        driver = GoogleGenaiModelDriver(tools_adapter=tools_adapter)
-        return LLMAgent(self, tools_adapter, agent_name=agent_name, **kwargs)
+    @property
+    def driver_config(self):
+        """Public, read-only access to the provider's LLMDriverConfig object."""
+        return self._driver_config
 
     def execute_tool(self, tool_name: str, event_bus, *args, **kwargs):
         self._tools_adapter.event_bus = event_bus

janito/providers/mistralai/provider.py

@@ -3,7 +3,7 @@ from janito.llm.model import LLMModelInfo
 from janito.llm.auth import LLMAuthManager
 from janito.llm.driver_config import LLMDriverConfig
 from janito.drivers.mistralai.driver import MistralAIModelDriver
-from janito.tools.adapters.local.adapter import LocalToolsAdapter
+from janito.tools import get_local_tools_adapter
 from janito.providers.registry import LLMProviderRegistry
 
 from .model_info import MODEL_SPECS
@@ -29,7 +29,7 @@ class MistralAIProvider(LLMProvider):
             return
         self.auth_manager = auth_manager or LLMAuthManager()
         self._api_key = self.auth_manager.get_credentials(type(self).name)
-        self._tools_adapter = LocalToolsAdapter()
+        self._tools_adapter = get_local_tools_adapter()
         self._info = config or LLMDriverConfig(model=None)
         if not self._info.model:
             self._info.model = self.DEFAULT_MODEL

janito/providers/provider_static_info.py

@@ -1,14 +1,13 @@
 # Provider static metadata registry for listing purposes (name, maintainer, and future fields)
 STATIC_PROVIDER_METADATA = {
     "openai": {
+    },
+    "google": {
         "maintainer": "João Pinto <lamego.pinto@gmail.com>",
     },
     "azure_openai": {
         "maintainer": "João Pinto <lamego.pinto@gmail.com>",
     },
-    "google": {
-        "maintainer": "Needs maintainer",
-    },
     "mistralai": {
         "maintainer": "Needs maintainer",
     },

janito/tools/adapters/__init__.py

@@ -1 +1 @@
-# Tools providers package: for plug-and-play tool collections, integrations, and adapters.
+# Tools providers package: for plug-and-play tool collections, integrations, and adapters.

janito/tools/adapters/local/adapter.py

@@ -3,20 +3,35 @@ from janito.tools.tools_adapter import ToolsAdapterBase as ToolsAdapter
 
 
 class LocalToolsAdapter(ToolsAdapter):
-    def disable_execution_tools(self):
-        """Unregister all tools with provides_execution = True."""
-        to_remove = [name for name, entry in self._tools.items()
-                     if getattr(entry["instance"], "provides_execution", False)]
-        for name in to_remove:
-            self.unregister_tool(name)
+    def set_execution_tools_enabled(self, enabled: bool):
+        """
+        Dynamically include or exclude execution tools from the enabled_tools set.
+        If enabled_tools is None, all tools are enabled (default). If set, restricts enabled tools.
+        """
+        all_tool_names = set(self._tools.keys())
+        exec_tool_names = {
+            name for name, entry in self._tools.items()
+            if getattr(entry["instance"], "provides_execution", False)
+        }
+        if self._enabled_tools is None:
+            # If not restricted, create a new enabled-tools set excluding execution tools if disabling
+            if enabled:
+                self._enabled_tools = None  # all tools enabled
+            else:
+                self._enabled_tools = all_tool_names - exec_tool_names
+        else:
+            if enabled:
+                self._enabled_tools |= exec_tool_names
+            else:
+                self._enabled_tools -= exec_tool_names
 
     """
     Adapter for local, statically registered tools in the agent/tools system.
     Handles registration, lookup, enabling/disabling, listing, and now, tool execution (merged from executor).
     """
 
-    def __init__(self, tools=None, event_bus=None, allowed_tools=None, workdir=None):
-        super().__init__(tools=tools, event_bus=event_bus, allowed_tools=allowed_tools)
+    def __init__(self, tools=None, event_bus=None, enabled_tools=None, workdir=None):
+        super().__init__(tools=tools, event_bus=event_bus, enabled_tools=enabled_tools)
         self._tools: Dict[str, Dict[str, Any]] = {}
         self.workdir = workdir
         if self.workdir:
@@ -56,13 +71,19 @@ class LocalToolsAdapter(ToolsAdapter):
         return self._tools[name]["instance"] if name in self._tools else None
 
     def list_tools(self):
-        return list(self._tools.keys())
+        if self._enabled_tools is None:
+            return list(self._tools.keys())
+        return [name for name in self._tools.keys() if name in self._enabled_tools]
 
     def get_tool_classes(self):
-        return [entry["class"] for entry in self._tools.values()]
+        if self._enabled_tools is None:
+            return [entry["class"] for entry in self._tools.values()]
+        return [entry["class"] for name, entry in self._tools.items() if name in self._enabled_tools]
 
     def get_tools(self):
-        return [entry["instance"] for entry in self._tools.values()]
+        if self._enabled_tools is None:
+            return [entry["instance"] for entry in self._tools.values()]
+        return [entry["instance"] for name, entry in self._tools.items() if name in self._enabled_tools]
 
 
     def add_tool(self, tool):
@@ -94,3 +115,4 @@ def register_local_tool(tool=None):
     if tool is None:
         return decorator
     return decorator(tool)
+