janito 2.6.1__py3-none-any.whl → 2.8.0__py3-none-any.whl

janito/providers/anthropic/provider.py

@@ -1,80 +1,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.tools import get_local_tools_adapter
-from janito.providers.registry import LLMProviderRegistry
-
-from .model_info import MODEL_SPECS
-
-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 import get_local_tools_adapter
-from janito.providers.registry import LLMProviderRegistry
-from .model_info import MODEL_SPECS
-from janito.drivers.openai.driver import OpenAIModelDriver
-
-class AnthropicProvider(LLMProvider):
-    name = "anthropic"
-    maintainer = "Needs maintainer"
-    MODEL_SPECS = MODEL_SPECS
-    DEFAULT_MODEL = "claude-3-7-sonnet-20250219"
-
-    def __init__(
-        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
-    ):
-        self._tools_adapter = get_local_tools_adapter()
-        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 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 Anthropic OpenAI-compatible API endpoint
-        self._driver_config.base_url = "https://api.anthropic.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"AnthropicProvider unavailable: {self.unavailable_reason}")
-        return self._driver
-
-    @property
-    def available(self):
-        return OpenAIModelDriver.available
-
-    @property
-    def unavailable_reason(self):
-        return OpenAIModelDriver.unavailable_reason
-
-    def create_driver(self):
-        """
-        Creates and returns a new OpenAIModelDriver instance configured for Anthropic API.
-        """
-        driver = OpenAIModelDriver(
-            tools_adapter=self._tools_adapter, provider_name=self.name
-        )
-        driver.config = self._driver_config
-        return driver
-
-    @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(AnthropicProvider.name, AnthropicProvider)
+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 import get_local_tools_adapter
+from janito.providers.registry import LLMProviderRegistry
+from .model_info import MODEL_SPECS
+from janito.drivers.openai.driver import OpenAIModelDriver
+
+
+class AnthropicProvider(LLMProvider):
+    name = "anthropic"
+    NAME = "anthropic"
+    MAINTAINER = "Alberto Minetti <alberto.minetti@gmail.com>"
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = "claude-3-7-sonnet-20250219"
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        self._tools_adapter = get_local_tools_adapter()
+        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 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 Anthropic OpenAI-compatible API endpoint
+        self._driver_config.base_url = "https://api.anthropic.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"AnthropicProvider unavailable: {self.unavailable_reason}"
+            )
+        return self._driver
+
+    @property
+    def available(self):
+        return OpenAIModelDriver.available
+
+    @property
+    def unavailable_reason(self):
+        return OpenAIModelDriver.unavailable_reason
+
+    def create_driver(self):
+        """
+        Creates and returns a new OpenAIModelDriver instance configured for Anthropic API.
+        """
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.name
+        )
+        driver.config = self._driver_config
+        return driver
+
+    @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(AnthropicProvider.NAME, AnthropicProvider)

janito/providers/azure_openai/provider.py

@@ -16,7 +16,8 @@ maintainer = "João Pinto <lamego.pinto@gmail.com>"
 
 class AzureOpenAIProvider(LLMProvider):
     name = "azure_openai"
-    maintainer = "João Pinto <lamego.pinto@gmail.com>"
+    NAME = "azure_openai"
+    MAINTAINER = "João Pinto <lamego.pinto@gmail.com>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = "azure_openai_deployment"
 
@@ -30,7 +31,7 @@ class AzureOpenAIProvider(LLMProvider):
             self._driver = None
             return
         self._auth_manager = auth_manager or LLMAuthManager()
-        self._api_key = self._auth_manager.get_credentials(type(self).name)
+        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:
@@ -41,6 +42,7 @@ class AzureOpenAIProvider(LLMProvider):
             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
@@ -76,7 +78,10 @@ class AzureOpenAIProvider(LLMProvider):
         """
         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()}
+            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
@@ -120,4 +125,4 @@ class AzureOpenAIProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(AzureOpenAIProvider.name, AzureOpenAIProvider)
+LLMProviderRegistry.register(AzureOpenAIProvider.NAME, AzureOpenAIProvider)

janito/providers/deepseek/provider.py

@@ -12,9 +12,10 @@ available = OpenAIModelDriver.available
 unavailable_reason = OpenAIModelDriver.unavailable_reason
 
 
-class DeepseekProvider(LLMProvider):
+class DeepSeekProvider(LLMProvider):
     name = "deepseek"
-    maintainer = "Needs maintainer"
+    NAME = "deepseek"
+    MAINTAINER = "João Pinto <lamego.pinto@gmail.com>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = "deepseek-chat"  # Options: deepseek-chat, deepseek-reasoner
 
@@ -28,7 +29,7 @@ class DeepseekProvider(LLMProvider):
             self._driver = None
         else:
             self.auth_manager = auth_manager or LLMAuthManager()
-            self._api_key = self.auth_manager.get_credentials(type(self).name)
+            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:
@@ -91,4 +92,4 @@ class DeepseekProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(DeepseekProvider.name, DeepseekProvider)
+LLMProviderRegistry.register(DeepSeekProvider.NAME, DeepSeekProvider)

janito/providers/google/model_info.py

@@ -10,7 +10,7 @@ MODEL_SPECS = {
         max_cot=24576,
         thinking_supported=True,
     ),
-        "gemini-2.5-pro": LLMModelInfo(
+    "gemini-2.5-pro": LLMModelInfo(
         name="gemini-2.5-pro",
         other={"description": "Google Gemini 2.5 Pro (OpenAI-compatible endpoint)"},
         open="google",
@@ -21,7 +21,9 @@ MODEL_SPECS = {
     ),
     "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)"},
+        other={
+            "description": "Google Gemini 2.5 Flash-Lite Preview (OpenAI-compatible endpoint)"
+        },
         open="google",
         driver="OpenAIModelDriver",
         max_response=64000,

janito/providers/google/provider.py

@@ -13,9 +13,11 @@ try:
 except ImportError:
     MODEL_SPECS = {}
 
+
 class GoogleProvider(LLMProvider):
     name = "google"
-    maintainer = "João Pinto <lamego.pinto@gmail.com>"
+    NAME = "google"
+    MAINTAINER = "João Pinto <lamego.pinto@gmail.com>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = "gemini-2.5-flash"  # Default Gemini model
 
@@ -33,19 +35,23 @@ class GoogleProvider(LLMProvider):
             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):
+            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._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) -> OpenAIModelDriver:
         if not self.available:
-            raise ImportError(f"GoogleOpenAIProvider unavailable: {self.unavailable_reason}")
+            raise ImportError(
+                f"GoogleOpenAIProvider unavailable: {self.unavailable_reason}"
+            )
         return self._driver
 
     @property
@@ -80,4 +86,4 @@ class GoogleProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(GoogleProvider.name, GoogleProvider)
+LLMProviderRegistry.register(GoogleProvider.NAME, GoogleProvider)

janito/providers/groq/__init__.py

@@ -0,0 +1 @@
+from .provider import GroqProvider

janito/providers/groq/model_info.py

@@ -0,0 +1,46 @@
+# Groq provider model specifications
+from janito.llm.model import LLMModelInfo
+
+MODEL_SPECS = {
+    "moonshotai/kimi-k2-instruct": LLMModelInfo(
+        name="moonshotai/kimi-k2-instruct",
+        context=128000,
+        max_input=122880,
+        max_cot="N/A",
+        max_response=4096,
+        thinking_supported=False,
+        default_temp=0.2,
+        open="groq",
+        driver="GroqModelDriver",
+        other={
+            "description": "Kimi K2 Instruct model by Moonshot AI",
+            "supports_tools": True,
+            "supports_streaming": True,
+            "supports_vision": False,
+            "supports_system_prompt": True,
+            "supports_temperature": True,
+            "supports_top_p": True,
+            "supports_frequency_penalty": True,
+            "supports_presence_penalty": True,
+            "supports_stop_sequences": True,
+            "supports_max_tokens": True,
+            "supports_seed": False,
+            "supports_json_mode": True,
+            "supports_logprobs": False,
+            "supports_top_logprobs": False,
+            "supports_response_format": True,
+            "supports_n": False,
+            "supports_best_of": False,
+            "supports_echo": False,
+            "supports_logit_bias": False,
+            "supports_user": False,
+            "supports_assistant": False,
+            "supports_system": False,
+            "supports_functions": True,
+            "supports_tool_calls": True,
+            "supports_parallel_tool_calls": True,
+            "supports_stream_options": False,
+            "supports_include_usage": False,
+        },
+    )
+}

janito/providers/groq/provider.py

@@ -0,0 +1,76 @@
+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 GroqProvider(LLMProvider):
+    name = "groq"
+    NAME = "groq"
+    MAINTAINER = "Groq Inc. <support@groq.com>"
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = "moonshotai/kimi-k2-instruct"
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        if not self.available:
+            self._tools_adapter = get_local_tools_adapter()
+            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=self.DEFAULT_MODEL)
+            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
+            self._driver_config.base_url = "https://api.groq.com/openai/v1"
+            self.fill_missing_device_info(self._driver_config)
+            self._driver = None
+
+    @property
+    def driver(self) -> OpenAIModelDriver:
+        if not self.available:
+            raise ImportError(f"GroqProvider 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):
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.NAME
+        )
+        driver.config = self._driver_config
+        return driver
+
+    @property
+    def model_name(self):
+        return self._driver_config.model
+
+    @property
+    def driver_config(self):
+        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(GroqProvider.NAME, GroqProvider)

janito/providers/moonshotai/__init__.py

@@ -0,0 +1 @@
+# MoonshotAI provider package

janito/providers/moonshotai/model_info.py

@@ -0,0 +1,15 @@
+from janito.llm.model import LLMModelInfo
+
+MOONSHOTAI_MODEL_SPECS = {
+    "kimi-k2-0711-preview": LLMModelInfo(
+        name="kimi-k2-0711-preview",
+        context=128000,
+        max_input=100000,
+        max_cot="N/A",
+        max_response=4096,
+        thinking_supported=False,
+        default_temp=0.2,
+        open="moonshotai",
+        driver="OpenAIModelDriver",
+    ),
+}

janito/providers/moonshotai/provider.py

@@ -0,0 +1,89 @@
+from janito.llm.provider import LLMProvider
+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 MOONSHOTAI_MODEL_SPECS
+
+
+class MoonshotAIProvider(LLMProvider):
+    name = "moonshotai"
+    NAME = "moonshotai"
+    MAINTAINER = "João Pinto <lamego.pinto@gmail.com>"
+    MODEL_SPECS = MOONSHOTAI_MODEL_SPECS
+    DEFAULT_MODEL = "kimi-k2-0711-preview"
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        if not self.available:
+            self._tools_adapter = get_local_tools_adapter()
+            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 only the correct token parameter for the model
+            model_name = self._driver_config.model
+            model_spec = self.MODEL_SPECS.get(model_name)
+            if hasattr(self._driver_config, "max_tokens"):
+                self._driver_config.max_tokens = None
+            if hasattr(self._driver_config, "max_completion_tokens"):
+                self._driver_config.max_completion_tokens = None
+            if model_spec:
+                if getattr(model_spec, "thinking_supported", False):
+                    max_cot = getattr(model_spec, "max_cot", None)
+                    if max_cot and max_cot != "N/A":
+                        self._driver_config.max_completion_tokens = int(max_cot)
+                else:
+                    max_response = getattr(model_spec, "max_response", None)
+                    if max_response and max_response != "N/A":
+                        self._driver_config.max_tokens = int(max_response)
+            self.fill_missing_device_info(self._driver_config)
+            self._driver = None
+            # Set MoonshotAI base_url
+            self._driver_config.base_url = "https://api.moonshot.ai/v1"
+
+    @property
+    def driver(self) -> OpenAIModelDriver:
+        if not self.available:
+            raise ImportError(
+                f"MoonshotAIProvider unavailable: {self.unavailable_reason}"
+            )
+        return self._driver
+
+    @property
+    def available(self):
+        return OpenAIModelDriver.available
+
+    @property
+    def unavailable_reason(self):
+        return OpenAIModelDriver.unavailable_reason
+
+    def create_driver(self):
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.name
+        )
+        driver.config = self._driver_config
+        return driver
+
+    @property
+    def model_name(self):
+        return self._driver_config.model
+
+    @property
+    def driver_config(self):
+        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(MoonshotAIProvider.NAME, MoonshotAIProvider)

janito/providers/openai/provider.py

@@ -14,11 +14,10 @@ unavailable_reason = OpenAIModelDriver.unavailable_reason
 
 class OpenAIProvider(LLMProvider):
     name = "openai"
-    maintainer = "João Pinto <lamego.pinto@gmail.com>"
+    NAME = "openai"
+    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, 
-    )
+    DEFAULT_MODEL = "gpt-4.1"  # Options: gpt-4.1, gpt-4o, o3-mini, o4-mini,
 
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
@@ -31,7 +30,7 @@ class OpenAIProvider(LLMProvider):
             self._driver = None
         else:
             self.auth_manager = auth_manager or LLMAuthManager()
-            self._api_key = self.auth_manager.get_credentials(type(self).name)
+            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:
@@ -77,7 +76,7 @@ class OpenAIProvider(LLMProvider):
         Creates and returns a new OpenAIModelDriver instance with input/output queues.
         """
         driver = OpenAIModelDriver(
-            tools_adapter=self._tools_adapter, provider_name=self.name
+            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.
@@ -108,4 +107,4 @@ class OpenAIProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(OpenAIProvider.name, OpenAIProvider)
+LLMProviderRegistry.register(OpenAIProvider.NAME, OpenAIProvider)

janito/tools/__init__.py

@@ -7,6 +7,7 @@ from janito.tools.adapters.local import (
 def get_local_tools_adapter(workdir=None, allowed_permissions=None):
     # Use set_verbose_tools on the returned adapter to set verbosity as needed
     import os
+
     if workdir is not None and not os.path.exists(workdir):
         os.makedirs(workdir, exist_ok=True)
     # Permissions are now managed globally; ignore allowed_permissions argument except for backward compatibility
@@ -16,6 +17,7 @@ def get_local_tools_adapter(workdir=None, allowed_permissions=None):
     if workdir is not None:
         try:
             import os
+
             if not os.path.exists(workdir):
                 os.makedirs(workdir, exist_ok=True)
             os.chdir(workdir)