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

janito/llm/provider.py

@@ -1,196 +1,196 @@
-from abc import ABC, abstractmethod
-import importlib
-from janito.llm.driver import LLMDriver
-
-
-class LLMProvider(ABC):
-    def create_driver(self):
-        """
-        Returns a new instance of the configured driver for this provider.
-        Subclasses must implement this method.
-        """
-        raise NotImplementedError(
-            "LLMProvider subclasses must implement create_driver()."
-        )
-
-    """
-    Abstract base class for Large Language Model (LLM) providers.
-
-    Provider Usage and Driver Communication Flow:
-      1. Provider class is selected (e.g., OpenAIProvider, MistralProvider).
-      2. An instance of the provider is created. This instance is bound to a specific configuration (LLMDriverConfig) containing model, credentials, etc.
-      3. All drivers created by that provider instance are associated with the bound config.
-      4. To communicate with an LLM, call create_driver() on the provider instance, which yields a driver configured for the attached config. Every driver created via this method inherits the provider's configuration.
-
-    Key: You do not create/configure a driver directly—always go through the provider to ensure correct configuration binding to the provider instance.
-
-    Subclasses must implement the core interface for interacting with LLM APIs and define `provider_name` as a class attribute.
-    """
-
-    name: str = None  # Must be set on subclasses
-    DEFAULT_MODEL: str = None  # Should be set by subclasses
-
-    def __init_subclass__(cls, **kwargs):
-        super().__init_subclass__(**kwargs)
-        if (
-            not hasattr(cls, "name")
-            or not isinstance(getattr(cls, "name"), str)
-            or not cls.name
-        ):
-            raise TypeError(
-                f"Class {cls.__name__} must define a class attribute 'name' (non-empty str)"
-            )
-        if (
-            not hasattr(cls, "DEFAULT_MODEL")
-            or getattr(cls, "DEFAULT_MODEL", None) is None
-        ):
-            raise TypeError(
-                f"Class {cls.__name__} must define a class attribute 'DEFAULT_MODEL' (non-empty str)"
-            )
-
-    def fill_missing_device_info(self, config):
-        """
-        Fill missing LLMDriverConfig fields (max_tokens, temperature, etc) from MODEL_SPECS for the chosen model.
-        Mutates the config in place.
-        """
-        if not hasattr(self, "MODEL_SPECS"):
-            return
-        model_name = getattr(config, "model", None) or getattr(
-            self, "DEFAULT_MODEL", None
-        )
-        model_info = self.MODEL_SPECS.get(model_name)
-        if not model_info:
-            return
-        # Handle common fields from model_info
-        spec_dict = (
-            model_info.to_dict() if hasattr(model_info, "to_dict") else dict(model_info)
-        )
-        if (
-            hasattr(config, "max_tokens")
-            and getattr(config, "max_tokens", None) is None
-        ):
-            val = spec_dict.get("max_tokens") or spec_dict.get("max_response")
-            if val is not None:
-                try:
-                    config.max_tokens = int(val)
-                except Exception:
-                    pass
-        if (
-            hasattr(config, "temperature")
-            and getattr(config, "temperature", None) is None
-        ):
-            val = spec_dict.get("temperature")
-            if val is None:
-                val = spec_dict.get("default_temp")
-            if val is not None:
-                try:
-                    config.temperature = float(val)
-                except Exception:
-                    pass
-
-    @property
-    @abstractmethod
-    def driver(self) -> LLMDriver:
-        pass
-
-    def is_model_available(self, model_name):
-        """
-        Returns True if the given model is available for this provider.
-        Default implementation checks MODEL_SPECS; override for dynamic providers.
-        """
-        if not hasattr(self, "MODEL_SPECS"):
-            return False
-        return model_name in self.MODEL_SPECS
-
-    def get_model_info(self, model_name=None):
-        """
-        Return the info dict for a given model (driver, params, etc). If model_name is None, return all model info dicts.
-        MODEL_SPECS must be dict[str, LLMModelInfo].
-        """
-        if not hasattr(self, "MODEL_SPECS"):
-            raise NotImplementedError(
-                "This provider does not have a MODEL_SPECS attribute."
-            )
-        if model_name is None:
-            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()
-        return None
-
-    def _validate_model_specs(self):
-        if not hasattr(self, "MODEL_SPECS"):
-            raise NotImplementedError(
-                "This provider does not have a MODEL_SPECS attribute."
-            )
-
-    def _get_model_name_from_config(self, config):
-        return (config or {}).get("model_name", getattr(self, "DEFAULT_MODEL", None))
-
-    def _get_model_spec_entry(self, model_name):
-        spec = self.MODEL_SPECS.get(model_name, None)
-        if spec is None:
-            raise ValueError(f"Model '{model_name}' not found in MODEL_SPECS.")
-        return spec
-
-    def _get_driver_name_from_spec(self, spec):
-        driver_name = None
-        if hasattr(spec, "driver") and spec.driver:
-            driver_name = spec.driver
-        elif hasattr(spec, "other") and isinstance(spec.other, dict):
-            driver_name = spec.other.get("driver", None)
-        return driver_name
-
-    def _resolve_driver_class(self, driver_name):
-        if not driver_name:
-            raise NotImplementedError(
-                "No driver class found or specified for this MODEL_SPECS entry."
-            )
-        module_root = "janito.drivers"
-        probable_path = None
-        mapping = {
-            "OpenAIResponsesModelDriver": "openai_responses.driver",
-            "OpenAIModelDriver": "openai.driver",
-            "AzureOpenAIModelDriver": "azure_openai.driver",
-            "GoogleGenaiModelDriver": "google_genai.driver",
-        }
-        if driver_name in mapping:
-            probable_path = mapping[driver_name]
-            module_path = f"{module_root}.{probable_path}"
-            mod = importlib.import_module(module_path)
-            return getattr(mod, driver_name)
-        # Attempt dynamic fallback based on convention
-        if driver_name.endswith("ModelDriver"):
-            base = driver_name[: -len("ModelDriver")]
-            mod_name = base.replace("_", "").lower()
-            module_path = f"{module_root}.{mod_name}.driver"
-            try:
-                mod = importlib.import_module(module_path)
-                return getattr(mod, driver_name)
-            except Exception:
-                pass
-        raise NotImplementedError(
-            "No driver class found for driver_name: {}".format(driver_name)
-        )
-
-    def _validate_required_config(self, driver_class, config, driver_name):
-        required = getattr(driver_class, "required_config", None)
-        if required:
-            missing = [
-                k
-                for k in required
-                if not config or k not in config or config.get(k) in (None, "")
-            ]
-            if missing:
-                raise ValueError(
-                    f"Missing required config for {driver_name}: {', '.join(missing)}"
-                )
-
-    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
-        from janito.llm.agent import LLMAgent
-
-        # Dynamically create driver if supported, else fallback to existing.
-        driver = self.driver
-        return LLMAgent(self, tools_adapter, agent_name=agent_name, **kwargs)
+from abc import ABC, abstractmethod
+import importlib
+from janito.llm.driver import LLMDriver
+
+
+class LLMProvider(ABC):
+    def create_driver(self):
+        """
+        Returns a new instance of the configured driver for this provider.
+        Subclasses must implement this method.
+        """
+        raise NotImplementedError(
+            "LLMProvider subclasses must implement create_driver()."
+        )
+
+    """
+    Abstract base class for Large Language Model (LLM) providers.
+
+    Provider Usage and Driver Communication Flow:
+      1. Provider class is selected (e.g., OpenAIProvider, MistralProvider).
+      2. An instance of the provider is created. This instance is bound to a specific configuration (LLMDriverConfig) containing model, credentials, etc.
+      3. All drivers created by that provider instance are associated with the bound config.
+      4. To communicate with an LLM, call create_driver() on the provider instance, which yields a driver configured for the attached config. Every driver created via this method inherits the provider's configuration.
+
+    Key: You do not create/configure a driver directly—always go through the provider to ensure correct configuration binding to the provider instance.
+
+    Subclasses must implement the core interface for interacting with LLM APIs and define `provider_name` as a class attribute.
+    """
+
+    name: str = None  # Must be set on subclasses
+    DEFAULT_MODEL: str = None  # Should be set by subclasses
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        if (
+            not hasattr(cls, "name")
+            or not isinstance(getattr(cls, "name"), str)
+            or not cls.name
+        ):
+            raise TypeError(
+                f"Class {cls.__name__} must define a class attribute 'name' (non-empty str)"
+            )
+        if (
+            not hasattr(cls, "DEFAULT_MODEL")
+            or getattr(cls, "DEFAULT_MODEL", None) is None
+        ):
+            raise TypeError(
+                f"Class {cls.__name__} must define a class attribute 'DEFAULT_MODEL' (non-empty str)"
+            )
+
+    def fill_missing_device_info(self, config):
+        """
+        Fill missing LLMDriverConfig fields (max_tokens, temperature, etc) from MODEL_SPECS for the chosen model.
+        Mutates the config in place.
+        """
+        if not hasattr(self, "MODEL_SPECS"):
+            return
+        model_name = getattr(config, "model", None) or getattr(
+            self, "DEFAULT_MODEL", None
+        )
+        model_info = self.MODEL_SPECS.get(model_name)
+        if not model_info:
+            return
+        # Handle common fields from model_info
+        spec_dict = (
+            model_info.to_dict() if hasattr(model_info, "to_dict") else dict(model_info)
+        )
+        if (
+            hasattr(config, "max_tokens")
+            and getattr(config, "max_tokens", None) is None
+        ):
+            val = spec_dict.get("max_tokens") or spec_dict.get("max_response")
+            if val is not None:
+                try:
+                    config.max_tokens = int(val)
+                except Exception:
+                    pass
+        if (
+            hasattr(config, "temperature")
+            and getattr(config, "temperature", None) is None
+        ):
+            val = spec_dict.get("temperature")
+            if val is None:
+                val = spec_dict.get("default_temp")
+            if val is not None:
+                try:
+                    config.temperature = float(val)
+                except Exception:
+                    pass
+
+    @property
+    @abstractmethod
+    def driver(self) -> LLMDriver:
+        pass
+
+    def is_model_available(self, model_name):
+        """
+        Returns True if the given model is available for this provider.
+        Default implementation checks MODEL_SPECS; override for dynamic providers.
+        """
+        if not hasattr(self, "MODEL_SPECS"):
+            return False
+        return model_name in self.MODEL_SPECS
+
+    def get_model_info(self, model_name=None):
+        """
+        Return the info dict for a given model (driver, params, etc). If model_name is None, return all model info dicts.
+        MODEL_SPECS must be dict[str, LLMModelInfo].
+        """
+        if not hasattr(self, "MODEL_SPECS"):
+            raise NotImplementedError(
+                "This provider does not have a MODEL_SPECS attribute."
+            )
+        if model_name is None:
+            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()
+        return None
+
+    def _validate_model_specs(self):
+        if not hasattr(self, "MODEL_SPECS"):
+            raise NotImplementedError(
+                "This provider does not have a MODEL_SPECS attribute."
+            )
+
+    def _get_model_name_from_config(self, config):
+        return (config or {}).get("model_name", getattr(self, "DEFAULT_MODEL", None))
+
+    def _get_model_spec_entry(self, model_name):
+        spec = self.MODEL_SPECS.get(model_name, None)
+        if spec is None:
+            raise ValueError(f"Model '{model_name}' not found in MODEL_SPECS.")
+        return spec
+
+    def _get_driver_name_from_spec(self, spec):
+        driver_name = None
+        if hasattr(spec, "driver") and spec.driver:
+            driver_name = spec.driver
+        elif hasattr(spec, "other") and isinstance(spec.other, dict):
+            driver_name = spec.other.get("driver", None)
+        return driver_name
+
+    def _resolve_driver_class(self, driver_name):
+        if not driver_name:
+            raise NotImplementedError(
+                "No driver class found or specified for this MODEL_SPECS entry."
+            )
+        module_root = "janito.drivers"
+        probable_path = None
+        mapping = {
+            "OpenAIResponsesModelDriver": "openai_responses.driver",
+            "OpenAIModelDriver": "openai.driver",
+            "AzureOpenAIModelDriver": "azure_openai.driver",
+            "GoogleGenaiModelDriver": "google_genai.driver",
+        }
+        if driver_name in mapping:
+            probable_path = mapping[driver_name]
+            module_path = f"{module_root}.{probable_path}"
+            mod = importlib.import_module(module_path)
+            return getattr(mod, driver_name)
+        # Attempt dynamic fallback based on convention
+        if driver_name.endswith("ModelDriver"):
+            base = driver_name[: -len("ModelDriver")]
+            mod_name = base.replace("_", "").lower()
+            module_path = f"{module_root}.{mod_name}.driver"
+            try:
+                mod = importlib.import_module(module_path)
+                return getattr(mod, driver_name)
+            except Exception:
+                pass
+        raise NotImplementedError(
+            "No driver class found for driver_name: {}".format(driver_name)
+        )
+
+    def _validate_required_config(self, driver_class, config, driver_name):
+        required = getattr(driver_class, "required_config", None)
+        if required:
+            missing = [
+                k
+                for k in required
+                if not config or k not in config or config.get(k) in (None, "")
+            ]
+            if missing:
+                raise ValueError(
+                    f"Missing required config for {driver_name}: {', '.join(missing)}"
+                )
+
+    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
+        from janito.llm.agent import LLMAgent
+
+        # Dynamically create driver if supported, else fallback to existing.
+        driver = self.driver
+        return LLMAgent(self, tools_adapter, agent_name=agent_name, **kwargs)

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):
@@ -129,18 +147,24 @@ class ProviderRegistry:
         return (is_needs_maint, row[2] != "✅ Auth")
 
     def get_provider(self, provider_name):
-        """Return the provider class for the given provider name."""
+        """Return the provider class for the given provider name. Returns None if not found."""
         from janito.providers.registry import LLMProviderRegistry
 
         if not provider_name:
-            raise ValueError("Provider name must be specified.")
-        return LLMProviderRegistry.get(provider_name)
+            print("Error: Provider name must be specified.")
+            return None
+        provider_class = LLMProviderRegistry.get(provider_name)
+        if provider_class is None:
+            available = ', '.join(LLMProviderRegistry.list_providers())
+            print(f"Error: Provider '{provider_name}' is not recognized. Available providers: {available}.")
+            return None
+        return provider_class
 
     def get_instance(self, provider_name, config=None):
-        """Return an instance of the provider for the given provider name, optionally passing a config object."""
+        """Return an instance of the provider for the given provider name, optionally passing a config object. Returns None if not found."""
         provider_class = self.get_provider(provider_name)
         if provider_class is None:
-            raise ValueError(f"No provider class found for '{provider_name}'")
+            return None
         if config is not None:
             return provider_class(config=config)
         return provider_class()

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

@@ -1,22 +1,22 @@
-from janito.llm.model import LLMModelInfo
-
-MODEL_SPECS = {
-    "claude-3-opus-20240229": LLMModelInfo(
-        name="claude-3-opus-20240229",
-        max_response=200000,
-        default_temp=0.7,
-        driver="AnthropicModelDriver",
-    ),
-    "claude-3-sonnet-20240229": LLMModelInfo(
-        name="claude-3-sonnet-20240229",
-        max_response=200000,
-        default_temp=0.7,
-        driver="AnthropicModelDriver",
-    ),
-    "claude-3-haiku-20240307": LLMModelInfo(
-        name="claude-3-haiku-20240307",
-        max_response=200000,
-        default_temp=0.7,
-        driver="AnthropicModelDriver",
-    ),
-}
+from janito.llm.model import LLMModelInfo
+
+MODEL_SPECS = {
+    "claude-3-opus-20240229": LLMModelInfo(
+        name="claude-3-opus-20240229",
+        max_response=200000,
+        default_temp=0.7,
+        driver="AnthropicModelDriver",
+    ),
+    "claude-3-sonnet-20240229": LLMModelInfo(
+        name="claude-3-sonnet-20240229",
+        max_response=200000,
+        default_temp=0.7,
+        driver="AnthropicModelDriver",
+    ),
+    "claude-3-haiku-20240307": LLMModelInfo(
+        name="claude-3-haiku-20240307",
+        max_response=200000,
+        default_temp=0.7,
+        driver="AnthropicModelDriver",
+    ),
+}

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
@@ -28,7 +28,7 @@ class AnthropicProvider(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/azure_openai/model_info.py

@@ -1,14 +1,15 @@
 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="N/A",
-        max_input="N/A",
-        max_cot="N/A",
-        max_response="N/A",
-        thinking_supported=False,
-        default_temp=0.2,
+        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
@@ -28,7 +28,7 @@ class AzureOpenAIProvider(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._driver_config = config or LLMDriverConfig(model=None)
         if not self._driver_config.model:
             self._driver_config.model = self.DEFAULT_MODEL
@@ -36,6 +36,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 +66,38 @@ 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.
+        """
+        driver = AzureOpenAIModelDriver(tools_adapter=self._tools_adapter)
+        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
         from janito.drivers.azure_openai.driver import AzureOpenAIModelDriver
@@ -69,6 +106,11 @@ class AzureOpenAIProvider(LLMProvider):
         driver = AzureOpenAIModelDriver(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):
         # Use direct execution via adapter:
         self._tools_adapter.event_bus = event_bus

janito/providers/deepseek/__init__.py

@@ -1 +1 @@
-# Deepseek provider package marker
+# Deepseek provider package marker