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

janito/formatting_token.py

@@ -25,7 +25,9 @@ def format_tokens(n, tag=None, use_rich=False):
     return val
 
 
-def format_token_message_summary(msg_count, usage, width=96, use_rich=False, elapsed=None):
+def format_token_message_summary(
+    msg_count, usage, width=96, use_rich=False, elapsed=None
+):
     """
     Returns a string (rich or pt markup) summarizing message count, last token usage, and elapsed time.
     """
@@ -40,16 +42,22 @@ def format_token_message_summary(msg_count, usage, width=96, use_rich=False, ela
             f"Completion: {format_tokens(completion_tokens, 'tokens_out', use_rich)}, "
             f"Total: {format_tokens(total_tokens, 'tokens_total', use_rich)}"
         )
-    elapsed_part = f" | Elapsed: [cyan]{elapsed:.2f}s[/cyan]" if elapsed is not None else ""
+    elapsed_part = (
+        f" | Elapsed: [cyan]{elapsed:.2f}s[/cyan]" if elapsed is not None else ""
+    )
     return f"{left}{tokens_part}{elapsed_part}"
 
 
-def print_token_message_summary(console, msg_count=None, usage=None, width=96, elapsed=None):
+def print_token_message_summary(
+    console, msg_count=None, usage=None, width=96, elapsed=None
+):
     """Prints the summary using rich markup, using defaults from perf_singleton if not given. Optionally includes elapsed time."""
     if usage is None:
         usage = performance_collector.get_last_request_usage()
     if msg_count is None:
         msg_count = performance_collector.get_total_turns() or 0
-    line = format_token_message_summary(msg_count, usage, width, use_rich=True, elapsed=elapsed)
+    line = format_token_message_summary(
+        msg_count, usage, width, use_rich=True, elapsed=elapsed
+    )
     if line.strip():
         console.print(Rule(line))

janito/llm/agent.py

@@ -97,6 +97,7 @@ class LLMAgent:
             # Refresh allowed_permissions in context before rendering
             from janito.tools.permissions import get_global_allowed_permissions
             from janito.tools.tool_base import ToolPermissions
+
             perms = get_global_allowed_permissions()
             if isinstance(perms, ToolPermissions):
                 perm_str = ""
@@ -171,7 +172,7 @@ class LLMAgent:
         )
 
     def _process_next_response(
-        self, poll_timeout: float = 1.0, max_wait_time: float = 300.0
+        self, poll_timeout: float = 1.0, max_wait_time: float = 600.0
     ):
         """
         Wait for a single event from the output queue (with timeout), process it, and return the result.
@@ -213,7 +214,6 @@ class LLMAgent:
             ]:
                 return (event, False)
 
-
     def _get_event_from_output_queue(self, poll_timeout):
         try:
             return self.output_queue.get(timeout=poll_timeout)
@@ -306,6 +306,7 @@ class LLMAgent:
             config = self.llm_provider.driver_config
         loop_count = 1
         import threading
+
         cancel_event = threading.Event()
         while True:
             self._print_verbose_chat_loop(loop_count)
@@ -317,7 +318,9 @@ class LLMAgent:
                 cancel_event.set()
                 raise
             if getattr(self, "verbose_agent", False):
-                print(f"[agent] [DEBUG] Returned from _process_next_response: result={result}, added_tool_results={added_tool_results}")
+                print(
+                    f"[agent] [DEBUG] Returned from _process_next_response: result={result}, added_tool_results={added_tool_results}"
+                )
             if self._should_exit_chat_loop(result, added_tool_results):
                 return result
             loop_count += 1
@@ -332,11 +335,15 @@ class LLMAgent:
     def _should_exit_chat_loop(self, result, added_tool_results):
         if result is None:
             if getattr(self, "verbose_agent", False):
-                print("[agent] [INFO] Exiting chat loop: _process_next_response returned None result (likely timeout or error). Returning (None, False).")
+                print(
+                    "[agent] [INFO] Exiting chat loop: _process_next_response returned None result (likely timeout or error). Returning (None, False)."
+                )
             return True
         if not added_tool_results:
             if getattr(self, "verbose_agent", False):
-                print(f"[agent] [INFO] Exiting chat loop: _process_next_response returned added_tool_results=False (final response or no more tool calls). Returning result: {result}")
+                print(
+                    f"[agent] [INFO] Exiting chat loop: _process_next_response returned added_tool_results=False (final response or no more tool calls). Returning result: {result}"
+                )
             return True
         return False
 
@@ -434,7 +441,9 @@ class LLMAgent:
         config.model = model_name
         config.temperature = self._safe_float(getattr(model_spec, "default_temp", None))
         config.max_tokens = self._safe_int(getattr(model_spec, "max_response", None))
-        config.max_completion_tokens = self._safe_int(getattr(model_spec, "max_cot", None))
+        config.max_completion_tokens = self._safe_int(
+            getattr(model_spec, "max_cot", None)
+        )
         config.top_p = None
         config.presence_penalty = None
         config.frequency_penalty = None

janito/llm/driver.py

@@ -55,6 +55,7 @@ class LLMDriver(ABC):
         # Validate all tool schemas before starting the thread
         if self.tools_adapter is not None:
             from janito.tools.tools_schema import ToolSchemaBase
+
             validator = ToolSchemaBase()
             for tool in self.tools_adapter.get_tools():
                 # Validate the tool's class (not instance)

janito/provider_registry.py

@@ -1,178 +1,139 @@
-"""
-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 (render without rich formatting)
-        print("Supported LLM Providers")
-        # Build header from column titles
-        header_titles = [column.header or "" for column in table.columns]
-        print(" | ".join(header_titles))
-        # rich.table.Row objects in recent Rich versions don't expose a public `.cells` attribute.
-        # Instead, cell content is stored in each column's private `_cells` list.
-        for row_index, _ in enumerate(table.rows):
-            cells_text = [str(column._cells[row_index]) for column in table.columns]
-            ascii_row = " | ".join(cells_text).encode("ascii", "ignore").decode("ascii")
-            print(ascii_row)
-
-    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",
-            "anthropic": "janito.providers.anthropic.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.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):
+        from janito.providers.registry import LLMProviderRegistry
+
+        return LLMProviderRegistry.list_providers()
+
+    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 (render without rich formatting)
+        print("Supported LLM Providers")
+        # Build header from column titles
+        header_titles = [column.header or "" for column in table.columns]
+        print(" | ".join(header_titles))
+        # rich.table.Row objects in recent Rich versions don't expose a public `.cells` attribute.
+        # Instead, cell content is stored in each column's private `_cells` list.
+        for row_index, _ in enumerate(table.rows):
+            cells_text = [str(column._cells[row_index]) for column in table.columns]
+            ascii_row = " | ".join(cells_text).encode("ascii", "ignore").decode("ascii")
+            print(ascii_row)
+
+    def _get_provider_info(self, provider_name):
+        provider_class = LLMProviderRegistry.get(provider_name)
+        maintainer = getattr(provider_class, "MAINTAINER", "-")
+        maintainer = f"👤 {maintainer}" if maintainer != "-" else maintainer
+        model_names = self._get_model_names(provider_name)
+        skip = False
+        return (provider_name, maintainer, model_names, skip)
+
+    def _get_model_names(self, provider_name):
+        try:
+            provider_class = LLMProviderRegistry.get(provider_name)
+            module_parts = provider_class.__module__.split(".")
+            # Build the correct import path: janito.providers.{provider}.model_info
+            model_info_module = f"janito.providers.{provider_name}.model_info"
+            model_info_mod = __import__(model_info_module, fromlist=["MODEL_SPECS"])
+
+            # Handle different model spec variable names
+            model_specs = None
+            if hasattr(model_info_mod, "MODEL_SPECS"):
+                model_specs = model_info_mod.MODEL_SPECS
+            elif hasattr(model_info_mod, "MOONSHOTAI_MODEL_SPECS"):
+                model_specs = model_info_mod.MOONSHOTAI_MODEL_SPECS
+
+            if provider_name == "groq":
+                return "<any> (must be provided)"
+            if model_specs:
+                return ", ".join(model_specs.keys())
+            return "-"
+        except Exception as e:
+            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

@@ -4,3 +4,5 @@ import janito.providers.google.provider
 import janito.providers.azure_openai.provider
 import janito.providers.anthropic.provider
 import janito.providers.deepseek.provider
+import janito.providers.moonshotai.provider
+import janito.providers.groq.provider

janito/providers/anthropic/model_info.py

@@ -1,41 +1,40 @@
-from janito.llm.model import LLMModelInfo
-
-MODEL_SPECS = {
-    "claude-opus-4-20250514": LLMModelInfo(
-        name="claude-opus-4-20250514",
-        max_response=32000,
-        default_temp=0.7,
-        driver="OpenAIModelDriver",
-    ),
-    "claude-sonnet-4-20250514": LLMModelInfo(
-        name="claude-sonnet-4-20250514",
-        max_response=64000,
-        default_temp=0.7,
-        driver="OpenAIModelDriver",
-    ),
-    "claude-3-7-sonnet-20250219": LLMModelInfo(
-        name="claude-3-7-sonnet-20250219",
-        max_response=64000,
-        default_temp=0.7,
-        driver="OpenAIModelDriver",
-    ),
-    "claude-3-5-haiku-20241022": LLMModelInfo(
-        name="claude-3-5-haiku-20241022",
-        max_response=8192,
-        default_temp=0.7,
-        driver="OpenAIModelDriver",
-    ),
-    "claude-3-5-sonnet-20241022": LLMModelInfo(
-        name="claude-3-5-sonnet-20241022",
-        max_response=8192,
-        default_temp=0.7,
-        driver="OpenAIModelDriver",
-    ),
-    "claude-3-haiku-20240307": LLMModelInfo(
-        name="claude-3-haiku-20240307",
-        max_response=4096,
-        default_temp=0.7,
-        driver="OpenAIModelDriver",
-    ),
-}
-
+from janito.llm.model import LLMModelInfo
+
+MODEL_SPECS = {
+    "claude-opus-4-20250514": LLMModelInfo(
+        name="claude-opus-4-20250514",
+        max_response=32000,
+        default_temp=0.7,
+        driver="OpenAIModelDriver",
+    ),
+    "claude-sonnet-4-20250514": LLMModelInfo(
+        name="claude-sonnet-4-20250514",
+        max_response=64000,
+        default_temp=0.7,
+        driver="OpenAIModelDriver",
+    ),
+    "claude-3-7-sonnet-20250219": LLMModelInfo(
+        name="claude-3-7-sonnet-20250219",
+        max_response=64000,
+        default_temp=0.7,
+        driver="OpenAIModelDriver",
+    ),
+    "claude-3-5-haiku-20241022": LLMModelInfo(
+        name="claude-3-5-haiku-20241022",
+        max_response=8192,
+        default_temp=0.7,
+        driver="OpenAIModelDriver",
+    ),
+    "claude-3-5-sonnet-20241022": LLMModelInfo(
+        name="claude-3-5-sonnet-20241022",
+        max_response=8192,
+        default_temp=0.7,
+        driver="OpenAIModelDriver",
+    ),
+    "claude-3-haiku-20240307": LLMModelInfo(
+        name="claude-3-haiku-20240307",
+        max_response=4096,
+        default_temp=0.7,
+        driver="OpenAIModelDriver",
+    ),
+}