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

janito/provider_registry.py

@@ -1,152 +1,158 @@
-"""
-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."""
-        from janito.providers.registry import LLMProviderRegistry
-
-        if not provider_name:
-            raise ValueError("Provider name must be specified.")
-        return LLMProviderRegistry.get(provider_name)
-
-    def get_instance(self, provider_name, config=None):
-        """Return an instance of the provider for the given provider name, optionally passing a config object."""
-        provider_class = self.get_provider(provider_name)
-        if provider_class is None:
-            raise ValueError(f"No provider class found for '{provider_name}'")
-        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):
+        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/azure_openai/provider.py

@@ -55,6 +55,21 @@ class AzureOpenAIProvider(LLMProvider):
     def unavailable_reason(self):
         return unavailable_reason
 
+    def is_model_available(self, model_name):
+        """
+        Returns True for any model name, since Azure deployments are user-defined and not enumerable in advance.
+        """
+        return True
+
+    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
@@ -63,6 +78,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/model_info.py

@@ -6,8 +6,8 @@ MODEL_SPECS = {
         "family": "deepseek",
         "default": True,
     },
-    "deepseek-coder": {
-        "description": "DeepSeek Coder Model (OpenAI-compatible)",
+    "deepseek-reasoner": {
+        "description": "DeepSeek Reasoner Model (OpenAI-compatible)",
         "context_window": 8192,
         "max_tokens": 4096,
         "family": "deepseek",

janito/providers/deepseek/provider.py

@@ -16,7 +16,7 @@ class DeepseekProvider(LLMProvider):
     name = "deepseek"
     maintainer = "Needs maintainer"
     MODEL_SPECS = MODEL_SPECS
-    DEFAULT_MODEL = "deepseek-chat"  # Options: deepseek-chat, deepseek-coder
+    DEFAULT_MODEL = "deepseek-chat"  # Options: deepseek-chat, deepseek-reasoner
 
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None

janito/providers/openai/model_info.py

@@ -111,17 +111,6 @@ MODEL_SPECS = {
         open="openai",
         driver="OpenAIModelDriver",
     ),
-    "o4-mini-high": LLMModelInfo(
-        name="o4-mini-high",
-        context=200000,
-        max_input=100000,
-        max_cot="N/A",
-        max_response=100000,
-        thinking_supported=True,
-        default_temp=0.2,
-        open="openai",
-        driver="OpenAIModelDriver",
-    ),
     # duplicated gpt-4-turbo with minimal properties for distinction
     "gpt-4-turbo-alt": LLMModelInfo(
         name="gpt-4-turbo",

janito/providers/openai/provider.py

@@ -17,7 +17,7 @@ class OpenAIProvider(LLMProvider):
     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, o4-mini-high
+        "gpt-4.1"  # Options: gpt-4.1, gpt-4o, o3-mini, o4-mini, 
     )
 
     def __init__(

janito/providers/registry.py

@@ -1,26 +1,26 @@
-from typing import Type, Dict
-from janito.llm.provider import LLMProvider
-
-
-class LLMProviderRegistry:
-    """
-    Registry for LLM provider classes.
-    """
-
-    _providers: Dict[str, Type[LLMProvider]] = {}
-
-    @classmethod
-    def register(cls, name: str, provider_cls: Type[LLMProvider]):
-        if name in cls._providers:
-            raise ValueError(f"Provider '{name}' is already registered.")
-        cls._providers[name] = provider_cls
-
-    @classmethod
-    def get(cls, name: str) -> Type[LLMProvider]:
-        if name not in cls._providers:
-            raise KeyError(f"Provider '{name}' is not registered.")
-        return cls._providers[name]
-
-    @classmethod
-    def list_providers(cls):
-        return list(cls._providers.keys())
+from typing import Type, Dict
+from janito.llm.provider import LLMProvider
+
+
+class LLMProviderRegistry:
+    """
+    Registry for LLM provider classes.
+    """
+
+    _providers: Dict[str, Type[LLMProvider]] = {}
+
+    @classmethod
+    def register(cls, name: str, provider_cls: Type[LLMProvider]):
+        if name in cls._providers:
+            raise ValueError(f"Provider '{name}' is already registered.")
+        cls._providers[name] = provider_cls
+
+    @classmethod
+    def get(cls, name: str) -> Type[LLMProvider]:
+        if name not in cls._providers:
+            return None
+        return cls._providers[name]
+
+    @classmethod
+    def list_providers(cls):
+        return list(cls._providers.keys())

janito/tools/__init__.py

@@ -4,9 +4,13 @@ from janito.tools.adapters.local import (
 )
 
 
-def get_local_tools_adapter():
-
+def get_local_tools_adapter(workdir=None):
     # Use set_verbose_tools on the returned adapter to set verbosity as needed
+    if workdir is not None:
+        import os
+        if not os.path.exists(workdir):
+            os.makedirs(workdir, exist_ok=True)
+        return LocalToolsAdapter(workdir=workdir)
     return _internal_local_tools_adapter
 
 

janito/tools/adapters/local/__init__.py

@@ -1,57 +1,62 @@
-from .adapter import LocalToolsAdapter
-
-from .ask_user import AskUserTool
-from .copy_file import CopyFileTool
-from .create_directory import CreateDirectoryTool
-from .create_file import CreateFileTool
-from .fetch_url import FetchUrlTool
-from .find_files import FindFilesTool
-from .view_file import ViewFileTool
-from .move_file import MoveFileTool
-from .open_url import OpenUrlTool
-from .open_html_in_browser import OpenHtmlInBrowserTool
-from .python_code_run import PythonCodeRunTool
-from .python_command_run import PythonCommandRunTool
-from .python_file_run import PythonFileRunTool
-from .remove_directory import RemoveDirectoryTool
-from .remove_file import RemoveFileTool
-from .replace_text_in_file import ReplaceTextInFileTool
-from .run_bash_command import RunBashCommandTool
-from .run_powershell_command import RunPowershellCommandTool
-from .get_file_outline.core import GetFileOutlineTool
-from .get_file_outline.search_outline import SearchOutlineTool
-from .search_text.core import SearchTextTool
-from .validate_file_syntax.core import ValidateFileSyntaxTool
-
-# Singleton tools adapter with all standard tools registered
-local_tools_adapter = LocalToolsAdapter()
-
-# Register tools
-for tool_class in [
-    AskUserTool,
-    CopyFileTool,
-    CreateDirectoryTool,
-    CreateFileTool,
-    FetchUrlTool,
-    FindFilesTool,
-    ViewFileTool,
-    MoveFileTool,
-    OpenUrlTool,
-    OpenHtmlInBrowserTool,
-    PythonCodeRunTool,
-    PythonCommandRunTool,
-    PythonFileRunTool,
-    RemoveDirectoryTool,
-    RemoveFileTool,
-    ReplaceTextInFileTool,
-    RunBashCommandTool,
-    RunPowershellCommandTool,
-    GetFileOutlineTool,
-    SearchOutlineTool,
-    SearchTextTool,
-    ValidateFileSyntaxTool,
-]:
-    local_tools_adapter.register_tool(tool_class)
-
-# DEBUG: Print registered tools at startup
-
+from .adapter import LocalToolsAdapter
+
+from .ask_user import AskUserTool
+from .copy_file import CopyFileTool
+from .create_directory import CreateDirectoryTool
+from .create_file import CreateFileTool
+from .fetch_url import FetchUrlTool
+from .find_files import FindFilesTool
+from .view_file import ViewFileTool
+from .move_file import MoveFileTool
+from .open_url import OpenUrlTool
+from .open_html_in_browser import OpenHtmlInBrowserTool
+from .python_code_run import PythonCodeRunTool
+from .python_command_run import PythonCommandRunTool
+from .python_file_run import PythonFileRunTool
+from .remove_directory import RemoveDirectoryTool
+from .remove_file import RemoveFileTool
+from .replace_text_in_file import ReplaceTextInFileTool
+from .run_bash_command import RunBashCommandTool
+from .run_powershell_command import RunPowershellCommandTool
+from .get_file_outline.core import GetFileOutlineTool
+from .get_file_outline.search_outline import SearchOutlineTool
+from .search_text.core import SearchTextTool
+from .validate_file_syntax.core import ValidateFileSyntaxTool
+
+# Singleton tools adapter with all standard tools registered
+import os
+local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
+
+def get_local_tools_adapter(workdir=None):
+    import os
+    return LocalToolsAdapter(workdir=workdir or os.getcwd())
+
+# Register tools
+for tool_class in [
+    AskUserTool,
+    CopyFileTool,
+    CreateDirectoryTool,
+    CreateFileTool,
+    FetchUrlTool,
+    FindFilesTool,
+    ViewFileTool,
+    MoveFileTool,
+    OpenUrlTool,
+    OpenHtmlInBrowserTool,
+    PythonCodeRunTool,
+    PythonCommandRunTool,
+    PythonFileRunTool,
+    RemoveDirectoryTool,
+    RemoveFileTool,
+    ReplaceTextInFileTool,
+    RunBashCommandTool,
+    RunPowershellCommandTool,
+    GetFileOutlineTool,
+    SearchOutlineTool,
+    SearchTextTool,
+    ValidateFileSyntaxTool,
+]:
+    local_tools_adapter.register_tool(tool_class)
+
+# DEBUG: Print registered tools at startup
+

janito/tools/adapters/local/adapter.py

@@ -15,9 +15,13 @@ class LocalToolsAdapter(ToolsAdapter):
     Handles registration, lookup, enabling/disabling, listing, and now, tool execution (merged from executor).
     """
 
-    def __init__(self, tools=None, event_bus=None, allowed_tools=None):
+    def __init__(self, tools=None, event_bus=None, allowed_tools=None, workdir=None):
         super().__init__(tools=tools, event_bus=event_bus, allowed_tools=allowed_tools)
         self._tools: Dict[str, Dict[str, Any]] = {}
+        self.workdir = workdir
+        if self.workdir:
+            import os
+            os.chdir(self.workdir)
         if tools:
             for tool in tools:
                 self.register_tool(tool)

janito/tools/adapters/local/ask_user.py

@@ -43,26 +43,13 @@ class AskUserTool(ToolBase):
         def _(event):
             pass
 
-        # F12 instruction rotation
-        _f12_instructions = [
-            tr("proceed"),
-            tr("go ahead"),
-            tr("continue"),
-            tr("next"),
-            tr("okay"),
-        ]
-        _f12_index = {"value": 0}
-
         @bindings.add("f12")
         def _(event):
-            """When F12 is pressed, rotate through a set of short instructions."""
             buf = event.app.current_buffer
-            idx = _f12_index["value"]
-            buf.text = _f12_instructions[idx]
+            buf.text = "Do It"
             buf.validate_and_handle()
-            _f12_index["value"] = (idx + 1) % len(_f12_instructions)
 
-            # Use shared CLI styles
+        # Use shared CLI styles
 
         # prompt_style contains the prompt area and input background
         # toolbar_style contains the bottom-toolbar styling

janito/tools/adapters/local/find_files.py

@@ -21,12 +21,10 @@ class FindFilesTool(ToolBase):
             - If the pattern ends with '/' or '\', only matching directory names (with trailing slash) are returned, not the files within those directories. For example, pattern '*/' will return only directories at the specified depth.
         max_depth (int, optional): Maximum directory depth to search. If None, unlimited recursion. If 0, only the top-level directory. If 1, only the root directory (matches 'find . -maxdepth 1').
         include_gitignored (bool, optional): If True, includes files/directories ignored by .gitignore. Defaults to False.
-        max_results (int, optional): Maximum number of results to return. 0 means no limit (default).
     Returns:
         str: Newline-separated list of matching file paths. Example:
             "/path/to/file1.py\n/path/to/file2.py"
             "Warning: Empty file pattern provided. Operation skipped."
-            If max_results is reached, appends a note to the output.
     """
 
     tool_name = "find_files"