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

janito/provider_registry.py

@@ -1,158 +1,176 @@
-"""
-ProviderRegistry: Handles provider listing and selection logic for janito CLI.
-"""
-
-from rich.table import Table
-from janito.cli.console import shared_console
-from janito.providers.registry import LLMProviderRegistry
-from janito.providers.provider_static_info import STATIC_PROVIDER_METADATA
-from janito.llm.auth import LLMAuthManager
-import sys
-from janito.exceptions import MissingProviderSelectionException
-
-
-class ProviderRegistry:
-    def list_providers(self):
-        """List all supported LLM providers as a table using rich, showing if auth is configured and supported model names."""
-        providers = self._get_provider_names()
-        table = self._create_table()
-        rows = self._get_all_provider_rows(providers)
-        self._add_rows_to_table(table, rows)
-        self._print_table(table)
-
-    def _get_provider_names(self):
-        return list(STATIC_PROVIDER_METADATA.keys())
-
-    def _create_table(self):
-        table = Table(title="Supported LLM Providers")
-        table.add_column("Provider", style="cyan")
-        table.add_column("Maintainer", style="yellow", justify="center")
-        table.add_column("Model Names", style="magenta")
-        return table
-
-    def _get_all_provider_rows(self, providers):
-        rows = []
-        for p in providers:
-            info = self._get_provider_info(p)
-            # info is (provider_name, maintainer, model_names, skip)
-            if len(info) == 4 and info[3]:
-                continue  # skip providers flagged as not implemented
-            rows.append(info[:3])
-        rows.sort(key=self._maintainer_sort_key)
-        return rows
-
-    def _add_rows_to_table(self, table, rows):
-        for idx, (p, maintainer, model_names) in enumerate(rows):
-            table.add_row(p, maintainer, model_names)
-            if idx != len(rows) - 1:
-                table.add_section()
-
-    def _print_table(self, table):
-        shared_console.print(table)
-
-    def _get_provider_info(self, provider_name):
-        static_info = STATIC_PROVIDER_METADATA.get(provider_name, {})
-        maintainer_val = static_info.get("maintainer", "-")
-        maintainer = (
-            "[red]🚨 Needs maintainer[/red]"
-            if maintainer_val == "Needs maintainer"
-            else f"👤 {maintainer_val}"
-        )
-        model_names = "-"
-        unavailable_reason = None
-        skip = False
-        try:
-            provider_class = LLMProviderRegistry.get(provider_name)
-            creds = LLMAuthManager().get_credentials(provider_name)
-            provider_instance = None
-            instantiation_failed = False
-            try:
-                provider_instance = provider_class()
-            except NotImplementedError:
-                skip = True
-                unavailable_reason = "Not implemented"
-                model_names = f"[red]❌ Not implemented[/red]"
-            except Exception as e:
-                instantiation_failed = True
-                unavailable_reason = (
-                    f"Unavailable (import error or missing dependency): {str(e)}"
-                )
-                model_names = f"[red]❌ {unavailable_reason}[/red]"
-            if not instantiation_failed and provider_instance is not None:
-                available, unavailable_reason = self._get_availability(
-                    provider_instance
-                )
-                if (
-                    not available
-                    and unavailable_reason
-                    and "not implemented" in str(unavailable_reason).lower()
-                ):
-                    skip = True
-                if available:
-                    model_names = self._get_model_names(provider_name)
-                else:
-                    model_names = f"[red]❌ {unavailable_reason}[/red]"
-        except Exception as import_error:
-            model_names = f"[red]❌ Unavailable (cannot import provider module): {str(import_error)}[/red]"
-        return (provider_name, maintainer, model_names, skip)
-
-    def _get_availability(self, provider_instance):
-        try:
-            available = getattr(provider_instance, "available", True)
-            unavailable_reason = getattr(provider_instance, "unavailable_reason", None)
-        except Exception as e:
-            available = False
-            unavailable_reason = f"Error reading runtime availability: {str(e)}"
-        return available, unavailable_reason
-
-    def _get_model_names(self, provider_name):
-        provider_to_specs = {
-            "openai": "janito.providers.openai.model_info",
-            "azure_openai": "janito.providers.azure_openai.model_info",
-            "google": "janito.providers.google.model_info",
-            "mistralai": "janito.providers.mistralai.model_info",
-            "deepseek": "janito.providers.deepseek.model_info",
-        }
-        if provider_name in provider_to_specs:
-            try:
-                mod = __import__(
-                    provider_to_specs[provider_name], fromlist=["MODEL_SPECS"]
-                )
-                return ", ".join(mod.MODEL_SPECS.keys())
-            except Exception:
-                return "(Error)"
-        return "-"
-
-    def _maintainer_sort_key(self, row):
-        maint = row[1]
-        is_needs_maint = "Needs maintainer" in maint
-        return (is_needs_maint, row[2] != "✅ Auth")
-
-    def get_provider(self, 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:
-            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. Returns None if not found."""
-        provider_class = self.get_provider(provider_name)
-        if provider_class is None:
-            return None
-        if config is not None:
-            return provider_class(config=config)
-        return provider_class()
-
-
-# For backward compatibility
-def list_providers():
-    """Legacy function for listing providers, now uses ProviderRegistry class."""
-    ProviderRegistry().list_providers()
+"""
+ProviderRegistry: Handles provider listing and selection logic for janito CLI.
+"""
+
+from rich.table import Table
+from janito.cli.console import shared_console
+from janito.providers.registry import LLMProviderRegistry
+from janito.providers.provider_static_info import STATIC_PROVIDER_METADATA
+from janito.llm.auth import LLMAuthManager
+import sys
+from janito.exceptions import MissingProviderSelectionException
+
+
+class ProviderRegistry:
+    def list_providers(self):
+        """List all supported LLM providers as a table using rich, showing if auth is configured and supported model names."""
+        providers = self._get_provider_names()
+        table = self._create_table()
+        rows = self._get_all_provider_rows(providers)
+        self._add_rows_to_table(table, rows)
+        self._print_table(table)
+
+    def _get_provider_names(self):
+        return list(STATIC_PROVIDER_METADATA.keys())
+
+    def _create_table(self):
+        table = Table(title="Supported LLM Providers")
+        table.add_column("Provider", style="cyan")
+        table.add_column("Maintainer", style="yellow", justify="center")
+        table.add_column("Model Names", style="magenta")
+        return table
+
+    def _get_all_provider_rows(self, providers):
+        rows = []
+        for p in providers:
+            info = self._get_provider_info(p)
+            # info is (provider_name, maintainer, model_names, skip)
+            if len(info) == 4 and info[3]:
+                continue  # skip providers flagged as not implemented
+            rows.append(info[:3])
+        rows.sort(key=self._maintainer_sort_key)
+        return rows
+
+    def _add_rows_to_table(self, table, rows):
+        for idx, (p, maintainer, model_names) in enumerate(rows):
+            table.add_row(p, maintainer, model_names)
+            if idx != len(rows) - 1:
+                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):
+        static_info = STATIC_PROVIDER_METADATA.get(provider_name, {})
+        maintainer_val = static_info.get("maintainer", "-")
+        maintainer = (
+            "[red]🚨 Needs maintainer[/red]"
+            if maintainer_val == "Needs maintainer"
+            else f"👤 {maintainer_val}"
+        )
+        model_names = "-"
+        unavailable_reason = None
+        skip = False
+        try:
+            provider_class = LLMProviderRegistry.get(provider_name)
+            creds = LLMAuthManager().get_credentials(provider_name)
+            provider_instance = None
+            instantiation_failed = False
+            try:
+                provider_instance = provider_class()
+            except NotImplementedError:
+                skip = True
+                unavailable_reason = "Not implemented"
+                model_names = f"[red]❌ Not implemented[/red]"
+            except Exception as e:
+                instantiation_failed = True
+                unavailable_reason = (
+                    f"Unavailable (import error or missing dependency): {str(e)}"
+                )
+                model_names = f"[red]❌ {unavailable_reason}[/red]"
+            if not instantiation_failed and provider_instance is not None:
+                available, unavailable_reason = self._get_availability(
+                    provider_instance
+                )
+                if (
+                    not available
+                    and unavailable_reason
+                    and "not implemented" in str(unavailable_reason).lower()
+                ):
+                    skip = True
+                if available:
+                    model_names = self._get_model_names(provider_name)
+                else:
+                    model_names = f"[red]❌ {unavailable_reason}[/red]"
+        except Exception as import_error:
+            model_names = f"[red]❌ Unavailable (cannot import provider module): {str(import_error)}[/red]"
+        return (provider_name, maintainer, model_names, skip)
+
+    def _get_availability(self, provider_instance):
+        try:
+            available = getattr(provider_instance, "available", True)
+            unavailable_reason = getattr(provider_instance, "unavailable_reason", None)
+        except Exception as e:
+            available = False
+            unavailable_reason = f"Error reading runtime availability: {str(e)}"
+        return available, unavailable_reason
+
+    def _get_model_names(self, provider_name):
+        provider_to_specs = {
+            "openai": "janito.providers.openai.model_info",
+            "azure_openai": "janito.providers.azure_openai.model_info",
+            "google": "janito.providers.google.model_info",
+            "mistralai": "janito.providers.mistralai.model_info",
+            "deepseek": "janito.providers.deepseek.model_info",
+        }
+        if provider_name in provider_to_specs:
+            try:
+                mod = __import__(
+                    provider_to_specs[provider_name], fromlist=["MODEL_SPECS"]
+                )
+                return ", ".join(mod.MODEL_SPECS.keys())
+            except Exception:
+                return "(Error)"
+        return "-"
+
+    def _maintainer_sort_key(self, row):
+        maint = row[1]
+        is_needs_maint = "Needs maintainer" in maint
+        return (is_needs_maint, row[2] != "✅ Auth")
+
+    def get_provider(self, 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:
+            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. Returns None if not found."""
+        provider_class = self.get_provider(provider_name)
+        if provider_class is None:
+            return None
+        if config is not None:
+            return provider_class(config=config)
+        return provider_class()
+
+
+# For backward compatibility
+def list_providers():
+    """Legacy function for listing providers, now uses ProviderRegistry class."""
+    ProviderRegistry().list_providers()

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

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

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