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

janito/providers/deepseek/model_info.py

@@ -1,16 +1,16 @@
-MODEL_SPECS = {
-    "deepseek-chat": {
-        "description": "DeepSeek Chat Model (OpenAI-compatible)",
-        "context_window": 8192,
-        "max_tokens": 4096,
-        "family": "deepseek",
-        "default": True,
-    },
-    "deepseek-reasoner": {
-        "description": "DeepSeek Reasoner Model (OpenAI-compatible)",
-        "context_window": 8192,
-        "max_tokens": 4096,
-        "family": "deepseek",
-        "default": False,
-    },
-}
+MODEL_SPECS = {
+    "deepseek-chat": {
+        "description": "DeepSeek Chat Model (OpenAI-compatible)",
+        "context_window": 8192,
+        "max_tokens": 4096,
+        "family": "deepseek",
+        "default": True,
+    },
+    "deepseek-reasoner": {
+        "description": "DeepSeek Reasoner Model (OpenAI-compatible)",
+        "context_window": 8192,
+        "max_tokens": 4096,
+        "family": "deepseek",
+        "default": False,
+    },
+}

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/openai/model_info.py

@@ -111,17 +111,6 @@ MODEL_SPECS = {
         open="openai",
         driver="OpenAIModelDriver",
     ),
-    "o4-mini-high": LLMModelInfo(
-        name="o4-mini-high",
-        context=200000,
-        max_input=100000,
-        max_cot="N/A",
-        max_response=100000,
-        thinking_supported=True,
-        default_temp=0.2,
-        open="openai",
-        driver="OpenAIModelDriver",
-    ),
     # duplicated gpt-4-turbo with minimal properties for distinction
     "gpt-4-turbo-alt": LLMModelInfo(
         name="gpt-4-turbo",

janito/providers/openai/provider.py

@@ -17,7 +17,7 @@ class OpenAIProvider(LLMProvider):
     maintainer = "João Pinto <lamego.pinto@gmail.com>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = (
-        "gpt-4.1"  # Options: gpt-4.1, gpt-4o, o3-mini, o4-mini, o4-mini-high
+        "gpt-4.1"  # Options: gpt-4.1, gpt-4o, o3-mini, o4-mini, 
     )
 
     def __init__(

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/providers/registry.py

@@ -1,26 +1,26 @@
-from typing import Type, Dict
-from janito.llm.provider import LLMProvider
-
-
-class LLMProviderRegistry:
-    """
-    Registry for LLM provider classes.
-    """
-
-    _providers: Dict[str, Type[LLMProvider]] = {}
-
-    @classmethod
-    def register(cls, name: str, provider_cls: Type[LLMProvider]):
-        if name in cls._providers:
-            raise ValueError(f"Provider '{name}' is already registered.")
-        cls._providers[name] = provider_cls
-
-    @classmethod
-    def get(cls, name: str) -> Type[LLMProvider]:
-        if name not in cls._providers:
-            raise KeyError(f"Provider '{name}' is not registered.")
-        return cls._providers[name]
-
-    @classmethod
-    def list_providers(cls):
-        return list(cls._providers.keys())
+from typing import Type, Dict
+from janito.llm.provider import LLMProvider
+
+
+class LLMProviderRegistry:
+    """
+    Registry for LLM provider classes.
+    """
+
+    _providers: Dict[str, Type[LLMProvider]] = {}
+
+    @classmethod
+    def register(cls, name: str, provider_cls: Type[LLMProvider]):
+        if name in cls._providers:
+            raise ValueError(f"Provider '{name}' is already registered.")
+        cls._providers[name] = provider_cls
+
+    @classmethod
+    def get(cls, name: str) -> Type[LLMProvider]:
+        if name not in cls._providers:
+            return None
+        return cls._providers[name]
+
+    @classmethod
+    def list_providers(cls):
+        return list(cls._providers.keys())

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/__init__.py

@@ -1,62 +1,62 @@
-from .adapter import LocalToolsAdapter
-
-from .ask_user import AskUserTool
-from .copy_file import CopyFileTool
-from .create_directory import CreateDirectoryTool
-from .create_file import CreateFileTool
-from .fetch_url import FetchUrlTool
-from .find_files import FindFilesTool
-from .view_file import ViewFileTool
-from .move_file import MoveFileTool
-from .open_url import OpenUrlTool
-from .open_html_in_browser import OpenHtmlInBrowserTool
-from .python_code_run import PythonCodeRunTool
-from .python_command_run import PythonCommandRunTool
-from .python_file_run import PythonFileRunTool
-from .remove_directory import RemoveDirectoryTool
-from .remove_file import RemoveFileTool
-from .replace_text_in_file import ReplaceTextInFileTool
-from .run_bash_command import RunBashCommandTool
-from .run_powershell_command import RunPowershellCommandTool
-from .get_file_outline.core import GetFileOutlineTool
-from .get_file_outline.search_outline import SearchOutlineTool
-from .search_text.core import SearchTextTool
-from .validate_file_syntax.core import ValidateFileSyntaxTool
-
-# Singleton tools adapter with all standard tools registered
-import os
-local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
-
-def get_local_tools_adapter(workdir=None):
-    import os
-    return LocalToolsAdapter(workdir=workdir or os.getcwd())
-
-# Register tools
-for tool_class in [
-    AskUserTool,
-    CopyFileTool,
-    CreateDirectoryTool,
-    CreateFileTool,
-    FetchUrlTool,
-    FindFilesTool,
-    ViewFileTool,
-    MoveFileTool,
-    OpenUrlTool,
-    OpenHtmlInBrowserTool,
-    PythonCodeRunTool,
-    PythonCommandRunTool,
-    PythonFileRunTool,
-    RemoveDirectoryTool,
-    RemoveFileTool,
-    ReplaceTextInFileTool,
-    RunBashCommandTool,
-    RunPowershellCommandTool,
-    GetFileOutlineTool,
-    SearchOutlineTool,
-    SearchTextTool,
-    ValidateFileSyntaxTool,
-]:
-    local_tools_adapter.register_tool(tool_class)
-
-# DEBUG: Print registered tools at startup
-
+from .adapter import LocalToolsAdapter
+
+from .ask_user import AskUserTool
+from .copy_file import CopyFileTool
+from .create_directory import CreateDirectoryTool
+from .create_file import CreateFileTool
+from .fetch_url import FetchUrlTool
+from .find_files import FindFilesTool
+from .view_file import ViewFileTool
+from .move_file import MoveFileTool
+from .open_url import OpenUrlTool
+from .open_html_in_browser import OpenHtmlInBrowserTool
+from .python_code_run import PythonCodeRunTool
+from .python_command_run import PythonCommandRunTool
+from .python_file_run import PythonFileRunTool
+from .remove_directory import RemoveDirectoryTool
+from .remove_file import RemoveFileTool
+from .replace_text_in_file import ReplaceTextInFileTool
+from .run_bash_command import RunBashCommandTool
+from .run_powershell_command import RunPowershellCommandTool
+from .get_file_outline.core import GetFileOutlineTool
+from .get_file_outline.search_outline import SearchOutlineTool
+from .search_text.core import SearchTextTool
+from .validate_file_syntax.core import ValidateFileSyntaxTool
+
+# Singleton tools adapter with all standard tools registered
+import os
+local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
+
+def get_local_tools_adapter(workdir=None):
+    import os
+    return LocalToolsAdapter(workdir=workdir or os.getcwd())
+
+# Register tools
+for tool_class in [
+    AskUserTool,
+    CopyFileTool,
+    CreateDirectoryTool,
+    CreateFileTool,
+    FetchUrlTool,
+    FindFilesTool,
+    ViewFileTool,
+    MoveFileTool,
+    OpenUrlTool,
+    OpenHtmlInBrowserTool,
+    PythonCodeRunTool,
+    PythonCommandRunTool,
+    PythonFileRunTool,
+    RemoveDirectoryTool,
+    RemoveFileTool,
+    ReplaceTextInFileTool,
+    RunBashCommandTool,
+    RunPowershellCommandTool,
+    GetFileOutlineTool,
+    SearchOutlineTool,
+    SearchTextTool,
+    ValidateFileSyntaxTool,
+]:
+    local_tools_adapter.register_tool(tool_class)
+
+# DEBUG: Print registered tools at startup
+