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

janito/llm/auth.py

@@ -1,62 +1,63 @@
-"""
-LLMAuthManager: Handles authentication credentials for LLM providers, persisted in ~/.janito/auth.json or a custom path.
-"""
-
-import os
-import json
-from typing import Dict, Optional
-
-
-class LLMAuthManager:
-    """
-    Manages authentication tokens, API keys, or credentials for LLM providers.
-    Persists credentials in ~/.janito/auth.json or a custom path.
-    """
-
-    def __init__(self, auth_file: Optional[str] = None):
-        if auth_file is not None:
-            self._auth_file = os.path.expanduser(auth_file)
-        else:
-            self._auth_file = os.path.expanduser("~/.janito/auth.json")
-        self._credentials: Dict[str, str] = {}
-        self._load_credentials()
-
-    def _load_credentials(self):
-        if os.path.exists(self._auth_file):
-            try:
-                with open(self._auth_file, "r") as f:
-                    self._credentials = json.load(f)
-            except Exception:
-                self._credentials = {}
-        else:
-            self._credentials = {}
-
-    def _save_credentials(self):
-        os.makedirs(os.path.dirname(self._auth_file), exist_ok=True)
-        with open(self._auth_file, "w") as f:
-            json.dump(self._credentials, f, indent=2)
-
-    def set_credentials(self, provider_name: str, credentials: str) -> None:
-        """
-        Store credentials for a given provider and persist to disk. Raises ValueError if provider is unknown.
-        """
-        from janito.providers.registry import LLMProviderRegistry
-
-        if provider_name not in LLMProviderRegistry.list_providers():
-            raise ValueError(f"Unknown provider: {provider_name}")
-        self._credentials[provider_name] = credentials
-        self._save_credentials()
-
-    def get_credentials(self, provider_name: str) -> Optional[str]:
-        """
-        Retrieve credentials for a given provider.
-        """
-        return self._credentials.get(provider_name)
-
-    def remove_credentials(self, provider_name: str) -> None:
-        """
-        Remove credentials for a given provider and update disk.
-        """
-        if provider_name in self._credentials:
-            del self._credentials[provider_name]
-            self._save_credentials()
+"""
+LLMAuthManager: Handles authentication credentials for LLM providers, persisted in ~/.janito/auth.json or a custom path.
+"""
+
+import os
+import json
+from typing import Dict, Optional
+
+
+class LLMAuthManager:
+    """
+    Manages authentication tokens, API keys, or credentials for LLM providers.
+    Persists credentials in ~/.janito/auth.json or a custom path.
+    """
+
+    def __init__(self, auth_file: Optional[str] = None):
+        if auth_file is not None:
+            self._auth_file = os.path.expanduser(auth_file)
+        else:
+            self._auth_file = os.path.expanduser("~/.janito/auth.json")
+        self._credentials: Dict[str, str] = {}
+        self._load_credentials()
+
+    def _load_credentials(self):
+        if os.path.exists(self._auth_file):
+            try:
+                with open(self._auth_file, "r") as f:
+                    self._credentials = json.load(f)
+            except Exception:
+                self._credentials = {}
+        else:
+            self._credentials = {}
+
+    def _save_credentials(self):
+        os.makedirs(os.path.dirname(self._auth_file), exist_ok=True)
+        with open(self._auth_file, "w") as f:
+            json.dump(self._credentials, f, indent=2)
+            f.write("\n")
+
+    def set_credentials(self, provider_name: str, credentials: str) -> None:
+        """
+        Store credentials for a given provider and persist to disk. Raises ValueError if provider is unknown.
+        """
+        from janito.providers.registry import LLMProviderRegistry
+
+        if provider_name not in LLMProviderRegistry.list_providers():
+            raise ValueError(f"Unknown provider: {provider_name}")
+        self._credentials[provider_name] = credentials
+        self._save_credentials()
+
+    def get_credentials(self, provider_name: str) -> Optional[str]:
+        """
+        Retrieve credentials for a given provider.
+        """
+        return self._credentials.get(provider_name)
+
+    def remove_credentials(self, provider_name: str) -> None:
+        """
+        Remove credentials for a given provider and update disk.
+        """
+        if provider_name in self._credentials:
+            del self._credentials[provider_name]
+            self._save_credentials()

janito/llm/driver.py

@@ -122,11 +122,17 @@ class LLMDriver(ABC):
         if not self.available:
             self.handle_driver_unavailable(request_id)
             return
+        # Prepare payload for RequestStarted event
+        payload = {"provider_name": self.provider_name}
+        if hasattr(config, "model") and getattr(config, "model", None):
+            payload["model"] = getattr(config, "model")
+        elif hasattr(config, "model_name") and getattr(config, "model_name", None):
+            payload["model"] = getattr(config, "model_name")
         self.output_queue.put(
             RequestStarted(
                 driver_name=self.__class__.__name__,
                 request_id=request_id,
-                payload={"provider_name": self.provider_name},
+                payload=payload,
             )
         )
         # Check for cancel_event before starting

janito/llm/driver_config.py

@@ -23,6 +23,7 @@ class LLMDriverConfig:
     presence_penalty: Optional[float] = None
     frequency_penalty: Optional[float] = None
     stop: Optional[Any] = None  # list or string, depending on backend
+    reasoning_effort: Optional[str] = None
     extra: dict = field(
         default_factory=dict
     )  # for provider-specific miscellaneous config fields

janito/provider_config.py

@@ -36,6 +36,7 @@ def set_provider_config(provider, key, value):
     config.file_config["providers"] = cfg
     with open(config.config_path, "w", encoding="utf-8") as f:
         json.dump(config.file_config, f, indent=2)
+        f.write("\n")
 
 
 def set_provider_model_config(provider, model, key, value):
@@ -51,6 +52,7 @@ def set_provider_model_config(provider, model, key, value):
     config.file_config["providers"] = cfg
     with open(config.config_path, "w", encoding="utf-8") as f:
         json.dump(config.file_config, f, indent=2)
+        f.write("\n")
 
 
 def get_provider_model_config(provider, model):
@@ -71,9 +73,11 @@ def get_effective_model(provider=None, requested_model=None):
         provider_model = config.get_provider_config(provider).get("model")
         if provider_model:
             return provider_model
-    global_model = config.get("model")
-    if global_model:
-        return global_model
+    # Only use global model if no provider is specified
+    if provider is None:
+        global_model = config.get("model")
+        if global_model:
+            return global_model
     return None
 
 

janito/provider_registry.py

@@ -48,6 +48,24 @@ class ProviderRegistry:
                 table.add_section()
 
     def _print_table(self, table):
+        """Print the table using rich when running in a terminal; otherwise fall back to a plain ASCII listing.
+        This avoids UnicodeDecodeError when the parent process captures the output with a non-UTF8 encoding.
+        """
+        import sys
+
+        if sys.stdout.isatty():
+            # Safe to use rich's unicode output when attached to an interactive terminal.
+            shared_console.print(table)
+            return
+
+        # Fallback: plain ASCII output
+        print("Supported LLM Providers")
+        print("Provider | Maintainer | Model Names")
+        for row in table.rows:
+            # row is a rich.table.Row -> row.cells is a list of Text objects
+            cells_text = [str(cell) for cell in row.cells]
+            ascii_row = " | ".join(cells_text).encode("ascii", "ignore").decode("ascii")
+            print(ascii_row)
         shared_console.print(table)
 
     def _get_provider_info(self, provider_name):

janito/providers/__init__.py

@@ -1,5 +1,6 @@
 # Ensure all providers are registered by importing their modules
 import janito.providers.openai.provider
+import janito.providers.google.provider
 import janito.providers.mistralai.provider
 import janito.providers.google.provider
 import janito.providers.azure_openai.provider

janito/providers/anthropic/provider.py

@@ -2,7 +2,7 @@ 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.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
@@ -23,12 +23,14 @@ class AnthropicProvider(LLMProvider):
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
     ):
+        # Ensure we always have a tools adapter, even if the driver itself is unavailable.
+        self._tools_adapter = get_local_tools_adapter()
         if not self.available:
             self._driver = None
             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/azure_openai/model_info.py

@@ -1,15 +1,16 @@
-from janito.llm.model import LLMModelInfo
-
-MODEL_SPECS = {
-    "azure_openai_deployment": LLMModelInfo(
-        name="azure_openai_deployment",
-        context="N/A",
-        max_input="N/A",
-        max_cot="N/A",
-        max_response="N/A",
-        thinking_supported=False,
-        default_temp=0.2,
-        open="azure_openai",
-        driver="AzureOpenAIModelDriver",
-    )
-}
+from janito.llm.model import LLMModelInfo
+from janito.providers.openai.model_info import MODEL_SPECS as OPENAI_MODEL_SPECS
+
+MODEL_SPECS = {
+    "azure_openai_deployment": LLMModelInfo(
+        name="azure_openai_deployment",
+        context=OPENAI_MODEL_SPECS["gpt-4o"].context,
+        max_input=OPENAI_MODEL_SPECS["gpt-4o"].max_input,
+        max_cot=OPENAI_MODEL_SPECS["gpt-4o"].max_cot,
+        max_response=OPENAI_MODEL_SPECS["gpt-4o"].max_response,
+        thinking_supported=OPENAI_MODEL_SPECS["gpt-4o"].thinking_supported,
+        default_temp=OPENAI_MODEL_SPECS["gpt-4o"].default_temp,
+        open="azure_openai",
+        driver="AzureOpenAIModelDriver",
+    )
+}

janito/providers/azure_openai/provider.py

@@ -2,7 +2,7 @@ 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.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
@@ -23,12 +23,15 @@ class AzureOpenAIProvider(LLMProvider):
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
     ):
+        # Always create a tools adapter so that provider.execute_tool() works even when
+        # the underlying driver is not available (e.g. OpenAI SDK not installed).
+        self._tools_adapter = get_local_tools_adapter()
         if not self.available:
             self._driver = None
             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._driver_config = config or LLMDriverConfig(model=None)
         if not self._driver_config.model:
             self._driver_config.model = self.DEFAULT_MODEL
@@ -36,6 +39,11 @@ class AzureOpenAIProvider(LLMProvider):
             self._driver_config.api_key = self._api_key
         if not self._driver_config.extra.get("api_version"):
             self._driver_config.extra["api_version"] = "2023-05-15"
+        # Inject azure_deployment_name from config if present
+        from janito.config import config as global_config
+        deployment_name = global_config.get("azure_deployment_name")
+        if deployment_name:
+            self._driver_config.extra["azure_deployment_name"] = deployment_name
         self.fill_missing_device_info(self._driver_config)
         self._driver = AzureOpenAIModelDriver(tools_adapter=self._tools_adapter)
 
@@ -61,6 +69,29 @@ class AzureOpenAIProvider(LLMProvider):
         """
         return True
 
+    def get_model_info(self, model_name=None):
+        """
+        For Azure OpenAI, accept any deployment name as a valid model name.
+        If the model_name is not in MODEL_SPECS, return a generic info dict.
+        """
+        if model_name is None:
+            # Return all known specs, but note: only static ones are listed
+            return {name: model_info.to_dict() for name, model_info in self.MODEL_SPECS.items()}
+        if model_name in self.MODEL_SPECS:
+            return self.MODEL_SPECS[model_name].to_dict()
+        # Accept any deployment name as a valid model
+        return {
+            "name": model_name,
+            "context": "N/A",
+            "max_input": "N/A",
+            "max_cot": "N/A",
+            "max_response": "N/A",
+            "thinking_supported": False,
+            "default_temp": 0.2,
+            "open": "azure_openai",
+            "driver": "AzureOpenAIModelDriver",
+        }
+
     def create_driver(self):
         """
         Creates and returns a new AzureOpenAIModelDriver instance with the provider's configuration and tools adapter.

janito/providers/deepseek/provider.py

@@ -21,6 +21,9 @@ class DeepseekProvider(LLMProvider):
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
     ):
+        # Always set a tools adapter so that even if the driver is unavailable,
+        # generic code paths that expect provider.execute_tool() continue to work.
+        self._tools_adapter = get_local_tools_adapter()
         if not self.available:
             self._driver = None
         else:

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,78 @@ 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
+    ):
+        # Always have a tools adapter available to avoid AttributeError downstream when
+        # the driver is missing but other logic still relies on tools execution.
+        self._tools_adapter = get_local_tools_adapter()
         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
@@ -24,12 +24,15 @@ class MistralAIProvider(LLMProvider):
     def __init__(
         self, config: LLMDriverConfig = None, auth_manager: LLMAuthManager = None
     ):
+        # Always instantiate a tools adapter so that provider.execute_tool() remains functional
+        # even when the driver cannot be constructed due to missing dependencies.
+        self._tools_adapter = get_local_tools_adapter()
         if not self.available:
             self._driver = None
             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/provider.py

@@ -24,6 +24,10 @@ class OpenAIProvider(LLMProvider):
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
     ):
         if not self.available:
+            # Even when the OpenAI driver is unavailable we still need a tools adapter
+            # so that any generic logic that expects `execute_tool()` to work does not
+            # crash with an AttributeError when it tries to access `self._tools_adapter`.
+            self._tools_adapter = get_local_tools_adapter()
             self._driver = None
         else:
             self.auth_manager = auth_manager or LLMAuthManager()

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",
     },