janito 2.27.1__py3-none-any.whl → 2.29.0__py3-none-any.whl

janito/plugins/manager.py

@@ -23,13 +23,13 @@ class PluginManager:
     """
     Manages plugin loading, registration, and lifecycle.
     """
-    
+
     def __init__(self, tools_adapter: Optional[LocalToolsAdapter] = None):
         self.tools_adapter = tools_adapter or LocalToolsAdapter()
         self.plugins: Dict[str, Plugin] = {}
         self.plugin_configs: Dict[str, Dict[str, Any]] = {}
         self.plugin_paths: List[Path] = []
-        
+
     def add_plugin_path(self, path: str) -> None:
         """Add a directory to search for plugins."""
         plugin_path = Path(path)
@@ -37,15 +37,17 @@ class PluginManager:
             self.plugin_paths.append(plugin_path)
             if str(plugin_path) not in sys.path:
                 sys.path.insert(0, str(plugin_path))
-    
-    def load_plugin(self, plugin_name: str, config: Optional[Dict[str, Any]] = None) -> bool:
+
+    def load_plugin(
+        self, plugin_name: str, config: Optional[Dict[str, Any]] = None
+    ) -> bool:
         """
         Load a plugin by name.
-        
+
         Args:
             plugin_name: Name of the plugin to load
             config: Optional configuration for the plugin
-            
+
         Returns:
             True if plugin loaded successfully
         """
@@ -53,47 +55,47 @@ class PluginManager:
             if plugin_name in self.plugins:
                 logger.warning(f"Plugin {plugin_name} already loaded")
                 return True
-                
+
             plugin = discover_plugins(plugin_name, self.plugin_paths)
             if not plugin:
                 logger.error(f"Plugin {plugin_name} not found")
                 return False
-            
+
             # Store config
             if config:
                 self.plugin_configs[plugin_name] = config
-            
+
             # Validate config if provided
-            if config and hasattr(plugin, 'validate_config'):
+            if config and hasattr(plugin, "validate_config"):
                 if not plugin.validate_config(config):
                     logger.error(f"Invalid configuration for plugin {plugin_name}")
                     return False
-            
+
             # Initialize plugin
             plugin.initialize()
-            
+
             # Register tools
             tools = plugin.get_tools()
             for tool_class in tools:
                 self.tools_adapter.register_tool(tool_class)
-            
+
             # Store plugin
             self.plugins[plugin_name] = plugin
-            
+
             logger.info(f"Successfully loaded plugin: {plugin_name}")
             return True
-            
+
         except Exception as e:
             logger.error(f"Failed to load plugin {plugin_name}: {e}")
             return False
-    
+
     def unload_plugin(self, plugin_name: str) -> bool:
         """
         Unload a plugin.
-        
+
         Args:
             plugin_name: Name of the plugin to unload
-            
+
         Returns:
             True if plugin unloaded successfully
         """
@@ -101,65 +103,65 @@ class PluginManager:
             if plugin_name not in self.plugins:
                 logger.warning(f"Plugin {plugin_name} not loaded")
                 return False
-            
+
             plugin = self.plugins[plugin_name]
-            
+
             # Unregister tools
             tools = plugin.get_tools()
             for tool_class in tools:
-                tool_name = getattr(tool_class(), 'tool_name', None)
+                tool_name = getattr(tool_class(), "tool_name", None)
                 if tool_name:
                     self.tools_adapter.unregister_tool(tool_name)
-            
+
             # Cleanup plugin
             plugin.cleanup()
-            
+
             # Remove from registry
             del self.plugins[plugin_name]
             if plugin_name in self.plugin_configs:
                 del self.plugin_configs[plugin_name]
-            
+
             logger.info(f"Successfully unloaded plugin: {plugin_name}")
             return True
-            
+
         except Exception as e:
             logger.error(f"Failed to unload plugin {plugin_name}: {e}")
             return False
-    
+
     def list_plugins(self) -> List[str]:
         """Return list of loaded plugin names."""
         return list(self.plugins.keys())
-    
+
     def get_plugin(self, plugin_name: str) -> Optional[Plugin]:
         """Get a loaded plugin by name."""
         return self.plugins.get(plugin_name)
-    
+
     def get_plugin_metadata(self, plugin_name: str) -> Optional[PluginMetadata]:
         """Get metadata for a loaded plugin."""
         plugin = self.plugins.get(plugin_name)
         return plugin.metadata if plugin else None
-    
+
     def load_plugins_from_config(self, config: Dict[str, Any]) -> None:
         """
         Load plugins from configuration.
-        
+
         Args:
             config: Configuration dict with plugin settings
         """
-        plugins_config = config.get('plugins', {})
-        
+        plugins_config = config.get("plugins", {})
+
         # Add plugin paths
-        for path in plugins_config.get('paths', []):
+        for path in plugins_config.get("paths", []):
             self.add_plugin_path(path)
-        
+
         # Load plugins
-        for plugin_name, plugin_config in plugins_config.get('load', {}).items():
+        for plugin_name, plugin_config in plugins_config.get("load", {}).items():
             if isinstance(plugin_config, bool):
                 if plugin_config:
                     self.load_plugin(plugin_name)
             else:
                 self.load_plugin(plugin_name, plugin_config)
-    
+
     def load_plugins_from_user_config(self) -> None:
         """
         Load plugins from user configuration directory.
@@ -167,63 +169,63 @@ class PluginManager:
         """
         config = load_plugins_config()
         self.load_plugins_from_config(config)
-    
+
     def reload_plugin(self, plugin_name: str) -> bool:
         """
         Reload a plugin.
-        
+
         Args:
             plugin_name: Name of the plugin to reload
-            
+
         Returns:
             True if plugin reloaded successfully
         """
         config = self.plugin_configs.get(plugin_name)
         self.unload_plugin(plugin_name)
         return self.load_plugin(plugin_name, config)
-    
+
     def get_loaded_plugins_info(self) -> Dict[str, Dict[str, Any]]:
         """Get information about all loaded plugins."""
         info = {}
         for name, plugin in self.plugins.items():
             info[name] = {
-                'metadata': plugin.metadata,
-                'tools': [tool.__name__ for tool in plugin.get_tools()],
-                'commands': list(plugin.get_commands().keys()),
-                'config': self.plugin_configs.get(name, {}),
-                'builtin': BuiltinPluginRegistry.is_builtin(name),
-                'resources': [
+                "metadata": plugin.metadata,
+                "tools": [tool.__name__ for tool in plugin.get_tools()],
+                "commands": list(plugin.get_commands().keys()),
+                "config": self.plugin_configs.get(name, {}),
+                "builtin": BuiltinPluginRegistry.is_builtin(name),
+                "resources": [
                     {
-                        'name': resource.name,
-                        'type': resource.type,
-                        'description': resource.description,
-                        'schema': resource.schema
+                        "name": resource.name,
+                        "type": resource.type,
+                        "description": resource.description,
+                        "schema": resource.schema,
                     }
                     for resource in plugin.get_resources()
-                ]
+                ],
             }
         return info
 
     def get_plugin_resources(self, plugin_name: str) -> List[Dict[str, Any]]:
         """
         Get resources provided by a specific plugin.
-        
+
         Args:
             plugin_name: Name of the plugin
-            
+
         Returns:
             List of resource dictionaries
         """
         plugin = self.plugins.get(plugin_name)
         if not plugin:
             return []
-        
+
         return [
             {
-                'name': resource.name,
-                'type': resource.type,
-                'description': resource.description,
-                'schema': resource.schema
+                "name": resource.name,
+                "type": resource.type,
+                "description": resource.description,
+                "schema": resource.schema,
             }
             for resource in plugin.get_resources()
         ]
@@ -231,11 +233,11 @@ class PluginManager:
     def list_all_resources(self) -> Dict[str, List[Dict[str, Any]]]:
         """
         List all resources from all loaded plugins.
-        
+
         Returns:
             Dict mapping plugin names to their resources
         """
         all_resources = {}
         for plugin_name in self.plugins:
             all_resources[plugin_name] = self.get_plugin_resources(plugin_name)
-        return all_resources
+        return all_resources

janito/provider_registry.py

@@ -39,16 +39,16 @@ class ProviderRegistry:
             if len(info) == 4 and info[3]:
                 continue  # skip providers flagged as not implemented
             rows.append(info[:3])
-        
+
         # Group providers by openness (open-source first, then proprietary)
-        open_providers = {'cerebras', 'deepseek', 'alibaba', 'moonshotai', 'zai'}
-        
+        open_providers = {"cerebras", "deepseek", "alibaba", "moonshot", "zai"}
+
         def sort_key(row):
             provider_name = row[0]
             is_open = provider_name in open_providers
             # Sort open providers alphabetically first, then proprietary alphabetically
             return (not is_open, provider_name)
-        
+
         rows.sort(key=sort_key)
         return rows
 
@@ -101,21 +101,21 @@ class ProviderRegistry:
             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
-            
+            elif hasattr(model_info_mod, "MOONSHOT_MODEL_SPECS"):
+                model_specs = model_info_mod.MOONSHOT_MODEL_SPECS
+
             if model_specs:
                 default_model = getattr(provider_class, "DEFAULT_MODEL", None)
                 model_names = []
-                
+
                 for model_key in model_specs.keys():
                     if model_key == default_model:
                         # Highlight the default model with color and star icon
                         model_names.append(f"[bold green]⭐ {model_key}[/bold green]")
                     else:
                         model_names.append(model_key)
-                
-                if provider_name == "moonshotai":
+
+                if provider_name == "moonshot":
                     return ", ".join(model_names)
                 return ", ".join(model_names)
             return "-"

janito/providers/__init__.py

@@ -4,7 +4,7 @@ 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.moonshot.provider
 import janito.providers.alibaba.provider
 import janito.providers.zai.provider
 import janito.providers.cerebras.provider

janito/providers/alibaba/model_info.py

@@ -12,7 +12,7 @@ MODEL_SPECS = {
         max_cot=8192,
     ),
     "qwen-plus": LLMModelInfo(
-        name="qwen-plus", 
+        name="qwen-plus",
         context=131072,
         max_response=8192,
         category="Alibaba Qwen Plus Model (OpenAI-compatible)",
@@ -23,7 +23,7 @@ MODEL_SPECS = {
     ),
     "qwen-max": LLMModelInfo(
         name="qwen-max",
-        context=32768, 
+        context=32768,
         max_response=8192,
         category="Alibaba Qwen Max Model (OpenAI-compatible)",
         driver="OpenAIModelDriver",
@@ -31,7 +31,6 @@ MODEL_SPECS = {
         thinking=False,
         max_cot=8192,
     ),
-
     "qwen3-coder-plus": LLMModelInfo(
         name="qwen3-coder-plus",
         context=1048576,
@@ -52,7 +51,6 @@ MODEL_SPECS = {
         thinking=False,
         max_cot=65536,
     ),
-    
     # Qwen3 1M context models (July 2025 update)
     "qwen3-235b-a22b-thinking-2507": LLMModelInfo(
         name="qwen3-235b-a22b-thinking-2507",
@@ -94,4 +92,4 @@ MODEL_SPECS = {
         thinking=False,
         max_cot=32768,
     ),
-}
+}

janito/providers/alibaba/provider.py

@@ -17,7 +17,9 @@ class AlibabaProvider(LLMProvider):
     NAME = "alibaba"
     MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
-    DEFAULT_MODEL = "qwen3-235b-a22b-instruct-2507"  # 129k context, general-purpose model
+    DEFAULT_MODEL = (
+        "qwen3-235b-a22b-instruct-2507"  # 129k context, general-purpose model
+    )
 
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None

janito/providers/cerebras/__init__.py

@@ -1 +1 @@
-# Cerebras provider package
+# Cerebras provider package

janito/providers/cerebras/model_info.py

@@ -11,11 +11,8 @@ MODEL_SPECS = {
         driver="CerebrasModelDriver",
         other={
             "description": "Qwen 3 32B model for general instruction following",
-            "pricing": {
-                "input_per_1k_tokens": 0.0002,
-                "output_per_1k_tokens": 0.0006
-            }
-        }
+            "pricing": {"input_per_1k_tokens": 0.0002, "output_per_1k_tokens": 0.0006},
+        },
     ),
     "qwen-3-235b-a22b-instruct-2507": LLMModelInfo(
         name="qwen-3-235b-a22b-instruct-2507",
@@ -25,11 +22,8 @@ MODEL_SPECS = {
         driver="CerebrasModelDriver",
         other={
             "description": "Qwen 3 235B A22B instruction-tuned model (preview)",
-            "pricing": {
-                "input_per_1k_tokens": 0.001,
-                "output_per_1k_tokens": 0.003
-            }
-        }
+            "pricing": {"input_per_1k_tokens": 0.001, "output_per_1k_tokens": 0.003},
+        },
     ),
     "qwen-3-235b-a22b-thinking-2507": LLMModelInfo(
         name="qwen-3-235b-a22b-thinking-2507",
@@ -39,11 +33,8 @@ MODEL_SPECS = {
         driver="CerebrasModelDriver",
         other={
             "description": "Qwen 3 235B A22B thinking model for reasoning tasks (preview)",
-            "pricing": {
-                "input_per_1k_tokens": 0.001,
-                "output_per_1k_tokens": 0.003
-            }
-        }
+            "pricing": {"input_per_1k_tokens": 0.001, "output_per_1k_tokens": 0.003},
+        },
     ),
     "qwen-3-coder-480b": LLMModelInfo(
         name="qwen-3-coder-480b",
@@ -53,11 +44,8 @@ MODEL_SPECS = {
         driver="CerebrasModelDriver",
         other={
             "description": "Qwen 3 Coder 480B model for programming tasks (preview)",
-            "pricing": {
-                "input_per_1k_tokens": 0.002,
-                "output_per_1k_tokens": 0.006
-            }
-        }
+            "pricing": {"input_per_1k_tokens": 0.002, "output_per_1k_tokens": 0.006},
+        },
     ),
     "gpt-oss-120b": LLMModelInfo(
         name="gpt-oss-120b",
@@ -67,10 +55,7 @@ MODEL_SPECS = {
         driver="CerebrasModelDriver",
         other={
             "description": "GPT-OSS 120B open-source model (preview)",
-            "pricing": {
-                "input_per_1k_tokens": 0.0008,
-                "output_per_1k_tokens": 0.0024
-            }
-        }
-    )
-}
+            "pricing": {"input_per_1k_tokens": 0.0008, "output_per_1k_tokens": 0.0024},
+        },
+    ),
+}

janito/providers/cerebras/provider.py

@@ -12,14 +12,16 @@ from .model_info import MODEL_SPECS
 
 class CerebrasProvider(LLMProvider):
     """Cerebras Inference API provider."""
-    
+
     name = "cerebras"
     NAME = "cerebras"
     DEFAULT_MODEL = "qwen-3-coder-480b"
     MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
 
-    def __init__(self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None):
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
         """Initialize Cerebras provider with optional configuration."""
         super().__init__()
         self._tools_adapter = get_local_tools_adapter()
@@ -32,10 +34,10 @@ class CerebrasProvider(LLMProvider):
         self._initialize_config(auth_manager, config)
         self._setup_model_config()
         self.fill_missing_device_info(self._driver_config)
-        
+
         if not self.available:
             return
-            
+
         self._initialize_config(None, None)
         self._driver_config.base_url = "https://api.cerebras.ai/v1"
 
@@ -72,11 +74,11 @@ class CerebrasProvider(LLMProvider):
             # Set context length
             if hasattr(model_spec, "context") and model_spec.context:
                 self._driver_config.context_length = model_spec.context
-            
+
             # Set max tokens based on model spec
             if hasattr(model_spec, "max_response") and model_spec.max_response:
                 self._driver_config.max_tokens = model_spec.max_response
-            
+
             # Set max completion tokens if thinking is supported
             if getattr(model_spec, "thinking_supported", False):
                 max_cot = getattr(model_spec, "max_cot", None)
@@ -130,10 +132,10 @@ class CerebrasProvider(LLMProvider):
                 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 execute_tool(self, tool_name: str, event_bus, *args, **kwargs):
@@ -142,4 +144,4 @@ class CerebrasProvider(LLMProvider):
 
 
 # Register the provider
-LLMProviderRegistry.register(CerebrasProvider.name, CerebrasProvider)
+LLMProviderRegistry.register(CerebrasProvider.name, CerebrasProvider)

janito/providers/mistral/__init__.py

@@ -1 +1 @@
-# Codestral provider module
+# Codestral provider module

janito/providers/mistral/model_info.py

@@ -78,4 +78,4 @@ MODEL_SPECS = {
         open="mistral",
         driver="OpenAIModelDriver",
     ),
-}
+}

janito/providers/mistral/provider.py

@@ -121,4 +121,4 @@ class MistralProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(MistralProvider.NAME, MistralProvider)
+LLMProviderRegistry.register(MistralProvider.NAME, MistralProvider)

janito/providers/moonshot/__init__.py

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

janito/providers/{moonshotai → moonshot}/model_info.py

@@ -1,6 +1,6 @@
 from janito.llm.model import LLMModelInfo
 
-MOONSHOTAI_MODEL_SPECS = {
+MOONSHOT_MODEL_SPECS = {
     "kimi-k2-0711-preview": LLMModelInfo(
         name="kimi-k2-0711-preview",
         context=128000,
@@ -9,7 +9,7 @@ MOONSHOTAI_MODEL_SPECS = {
         max_response=4096,
         thinking_supported=False,
         default_temp=0.2,
-        open="moonshotai",
+        open="moonshot",
         driver="OpenAIModelDriver",
     ),
     "kimi-k2-turbo-preview": LLMModelInfo(
@@ -20,7 +20,7 @@ MOONSHOTAI_MODEL_SPECS = {
         max_response=4096,
         thinking_supported=False,
         default_temp=0.2,
-        open="moonshotai",
+        open="moonshot",
         driver="OpenAIModelDriver",
     ),
 }

janito/providers/{moonshotai → moonshot}/provider.py

@@ -4,14 +4,14 @@ from janito.llm.driver_config import LLMDriverConfig
 from janito.drivers.openai.driver import OpenAIModelDriver
 from janito.tools import get_local_tools_adapter
 from janito.providers.registry import LLMProviderRegistry
-from .model_info import MOONSHOTAI_MODEL_SPECS
+from .model_info import MOONSHOT_MODEL_SPECS
 
 
-class MoonshotAIProvider(LLMProvider):
-    name = "moonshotai"
-    NAME = "moonshotai"
+class MoonshotProvider(LLMProvider):
+    name = "moonshot"
+    NAME = "moonshot"
     MAINTAINER = "João Pinto <janito@ikignosis.org>"
-    MODEL_SPECS = MOONSHOTAI_MODEL_SPECS
+    MODEL_SPECS = MOONSHOT_MODEL_SPECS
     DEFAULT_MODEL = "kimi-k2-turbo-preview"
 
     def __init__(
@@ -34,7 +34,7 @@ class MoonshotAIProvider(LLMProvider):
         if not self._api_key:
             from janito.llm.auth_utils import handle_missing_api_key
 
-            handle_missing_api_key(self.name, "MOONSHOTAI_API_KEY")
+            handle_missing_api_key(self.name, "MOONSHOT_API_KEY")
 
         self._driver_config = config or LLMDriverConfig(model=None)
         if not self._driver_config.model:
@@ -69,7 +69,7 @@ class MoonshotAIProvider(LLMProvider):
     def driver(self) -> OpenAIModelDriver:
         if not self.available:
             raise ImportError(
-                f"MoonshotAIProvider unavailable: {self.unavailable_reason}"
+                f"MoonshotProvider unavailable: {self.unavailable_reason}"
             )
         return self._driver
 
@@ -101,4 +101,4 @@ class MoonshotAIProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(MoonshotAIProvider.NAME, MoonshotAIProvider)
+LLMProviderRegistry.register(MoonshotProvider.NAME, MoonshotProvider)

janito/providers/openai/provider.py

@@ -17,7 +17,9 @@ class OpenAIProvider(LLMProvider):
     NAME = "openai"
     MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
-    DEFAULT_MODEL = "gpt-5"  # Options: gpt-4.1, gpt-4o, o3-mini, o4-mini, gpt-5, gpt-5-nano
+    DEFAULT_MODEL = (
+        "gpt-5"  # Options: gpt-4.1, gpt-4o, o3-mini, o4-mini, gpt-5, gpt-5-nano
+    )
 
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None

janito/report_events.py

@@ -14,7 +14,6 @@ class ReportSubtype(Enum):
     PROGRESS = "progress"
 
 
-
 class ReportAction(Enum):
     READ = "READ"
     CREATE = "CREATE"

janito/tools/adapters/local/create_file.py

@@ -25,7 +25,7 @@ class CreateFileTool(ToolBase):
             - "✅ Successfully created the file at ..."
 
     Note: Syntax validation is automatically performed after this operation.
-    
+
     Security: This tool includes loop protection to prevent excessive file creation operations.
     Maximum 5 calls per 10 seconds for the same file path.
     """