janito 1.14.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

janito/performance_collector.py

@@ -0,0 +1,167 @@
+from collections import defaultdict, Counter
+from janito.event_bus.handler import EventHandlerBase
+import janito.driver_events as driver_events
+import janito.report_events as report_events
+import janito.tools.tool_events as tool_events
+
+
+class PerformanceCollector(EventHandlerBase):
+    _last_request_usage = None
+
+    """
+    Aggregates performance metrics and statistics from LLM driver and report events.
+    Collects timing, token usage, status, error, turn, content part, and tool usage data.
+    Also tracks request durations.
+    """
+
+    def __init__(self):
+        super().__init__(driver_events, report_events, tool_events)
+        # Aggregated stats
+        self.total_requests = 0
+        self.status_counter = Counter()
+        self.token_usage = defaultdict(
+            int
+        )  # keys: total_tokens, prompt_tokens, completion_tokens
+        self.error_count = 0
+        self.error_messages = []
+        self.error_exceptions = []
+        self.total_turns = 0
+        self.generation_finished_count = 0
+        self.content_part_count = 0
+        # Duration tracking
+        self._request_start_times = dict()  # request_id -> timestamp
+        self._durations = []  # list of elapsed times (seconds)
+        # Tool stats
+        self.total_tool_events = 0
+        self.tool_names_counter = Counter()
+        self.tool_error_count = 0
+        self.tool_error_messages = []
+        self.tool_action_counter = Counter()
+        self.tool_subtype_counter = Counter()
+        # Raw events for reference
+        self._events = []
+
+    def on_RequestStarted(self, event):
+        self._events.append(("RequestStarted", event))
+        # Store the start time if possible
+        # Assumes 'event' has a unique .request_id and a .timestamp (in seconds)
+        request_id = event.request_id
+        timestamp = event.timestamp
+        if request_id is not None and timestamp is not None:
+            self._request_start_times[request_id] = timestamp
+
+    def on_RequestFinished(self, event):
+        self._events.append(("RequestFinished", event))
+        # Calculate and record the duration if start time is available
+        request_id = getattr(event, "request_id", None)
+        finish_time = getattr(event, "timestamp", None)
+        if request_id is not None and finish_time is not None:
+            start_time = self._request_start_times.pop(request_id, None)
+            if start_time is not None:
+                delta = finish_time - start_time
+                if hasattr(delta, "total_seconds"):
+                    self._durations.append(delta.total_seconds())
+                else:
+                    self._durations.append(float(delta))
+        self.total_requests += 1
+        self.status_counter[getattr(event, "status", None)] += 1
+        usage = getattr(event, "usage", None)
+        if usage:
+            self._last_request_usage = usage.copy()
+            for k, v in usage.items():
+                if isinstance(v, (int, float)):
+                    self.token_usage[k] += v
+        # Error handling
+        if getattr(event, "status", None) in ("error", "cancelled"):
+            self.error_count += 1
+            self.error_messages.append(getattr(event, "error", None))
+            self.error_exceptions.append(getattr(event, "exception", None))
+
+    def on_GenerationFinished(self, event):
+        self._events.append(("GenerationFinished", event))
+        self.generation_finished_count += 1
+        self.total_turns += event.total_turns
+
+    def on_ContentPartFound(self, event):
+        self._events.append(("ContentPartFound", event))
+        self.content_part_count += 1
+
+    def on_ToolCallStarted(self, event):
+        self._events.append(("ToolCallStarted", event))
+        self.total_tool_events += 1
+        self.tool_names_counter[event.tool_name] += 1
+
+    def on_ReportEvent(self, event):
+        self._events.append(("ReportEvent", event))
+        # Only count errors for reporting
+        if event.subtype:
+            self.tool_subtype_counter[str(event.subtype)] += 1
+            if str(event.subtype).lower() == "error":
+                self.tool_error_count += 1
+                self.tool_error_messages.append(event.message)
+
+    # --- Aggregated Data Accessors ---
+    def get_average_duration(self):
+        if not self._durations:
+            return 0.0
+        return sum(self._durations) / len(self._durations)
+
+    def get_total_requests(self):
+        return self.total_requests
+
+    def get_status_counts(self):
+        return dict(self.status_counter)
+
+    def get_token_usage(self):
+        return dict(self.token_usage)
+
+    def get_error_count(self):
+        return self.error_count
+
+    def get_error_messages(self):
+        return list(self.error_messages)
+
+    def get_total_turns(self):
+        return self.total_turns
+
+    def get_average_turns(self):
+        if self.generation_finished_count == 0:
+            return 0.0
+        return self.total_turns / self.generation_finished_count
+
+    def get_content_part_count(self):
+        return self.content_part_count
+
+    # --- Tool Stats Accessors ---
+    def get_total_tool_events(self):
+        return self.total_tool_events
+
+    def get_tool_names_counter(self):
+        return dict(self.tool_names_counter)
+
+    def get_tool_error_count(self):
+        return self.tool_error_count
+
+    def get_tool_error_messages(self):
+        return list(self.tool_error_messages)
+
+    def get_tool_action_counter(self):
+        return dict(self.tool_action_counter)
+
+    def get_tool_subtype_counter(self):
+        return dict(self.tool_subtype_counter)
+
+    def get_all_events(self):
+        return list(self._events)
+
+    def get_last_request_usage(self):
+        """
+        Returns the usage dict (tokens) from the most recent RequestFinished event, or None if not available.
+        """
+        return self._last_request_usage.copy() if self._last_request_usage else None
+
+    def reset_last_request_usage(self):
+        """
+        Clears the most recent usage dict. Use this (e.g. on session reset) to remove token/usage stats for toolbar.
+        """
+        self._last_request_usage = None

janito/provider_config.py

@@ -0,0 +1,98 @@
+"""
+ProviderConfigManager: Handles reading and writing provider configuration for janito.
+"""
+
+from janito.config import config
+from janito.llm.auth import LLMAuthManager
+
+
+def get_config_provider():
+    return config.get("provider")
+
+
+def set_config_provider(provider_name):
+    config.file_set("provider", provider_name)
+
+
+def get_config_path():
+    return str(config.config_path)
+
+
+def set_api_key(provider, api_key):
+    auth_manager = LLMAuthManager()
+    auth_manager.set_credentials(provider, api_key)
+
+
+def get_provider_config(provider):
+    return config.get_provider_config(provider)
+
+
+def set_provider_config(provider, key, value):
+    # Update provider config and persist immediately
+    cfg = config.file_config.get("providers", {})
+    if provider not in cfg:
+        cfg[provider] = {}
+    cfg[provider][key] = value
+    config.file_config["providers"] = cfg
+    with open(config.config_path, "w", encoding="utf-8") as f:
+        json.dump(config.file_config, f, indent=2)
+
+
+def set_provider_model_config(provider, model, key, value):
+    # Update provider-model config and persist immediately
+    cfg = config.file_config.get("providers", {})
+    if provider not in cfg:
+        cfg[provider] = {}
+    if "models" not in cfg[provider]:
+        cfg[provider]["models"] = {}
+    if model not in cfg[provider]["models"]:
+        cfg[provider]["models"][model] = {}
+    cfg[provider]["models"][model][key] = value
+    config.file_config["providers"] = cfg
+    with open(config.config_path, "w", encoding="utf-8") as f:
+        json.dump(config.file_config, f, indent=2)
+
+
+def get_provider_model_config(provider, model):
+    return config.get_provider_model_config(provider, model)
+
+
+def get_effective_model(provider=None, requested_model=None):
+    """
+    Returns the best model selection according to the following precedence:
+      1. If requested_model is provided, use it.
+      2. If a provider is set and provider.model is set, use it.
+      3. If a global model is set, use it.
+      Returns None if not found.
+    """
+    if requested_model:
+        return requested_model
+    if provider:
+        provider_model = config.get_provider_config(provider).get("model")
+        if provider_model:
+            return provider_model
+    global_model = config.get("model")
+    if global_model:
+        return global_model
+    return None
+
+
+def get_effective_setting(provider, model, setting):
+    """
+    Look up setting with the following order:
+      1. providers.{provider}.models.{model}.{setting}
+      2. providers.{provider}.{setting}
+      3. top-level {setting}
+      Returns None if not found.
+    """
+    # 1. provider-model
+    val = config.get_provider_model_config(provider, model).get(setting)
+    if val is not None:
+        return val
+    # 2. provider
+    val = config.get_provider_config(provider).get(setting)
+    if val is not None:
+        return val
+    # 3. top-level
+    val = config.get(setting)
+    return val

janito/provider_registry.py

@@ -0,0 +1,152 @@
+"""
+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()

janito/providers/__init__.py

@@ -0,0 +1,7 @@
+# Ensure all providers are registered by importing their modules
+import janito.providers.openai.provider
+import janito.providers.mistralai.provider
+import janito.providers.google.provider
+import janito.providers.azure_openai.provider
+import janito.providers.anthropic.provider
+import janito.providers.deepseek.provider

janito/providers/anthropic/model_info.py

@@ -0,0 +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",
+    ),
+}

janito/providers/anthropic/provider.py

@@ -0,0 +1,65 @@
+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.providers.registry import LLMProviderRegistry
+
+from .model_info import MODEL_SPECS
+
+from janito.drivers.anthropic.driver import AnthropicModelDriver
+
+available = AnthropicModelDriver.available
+unavailable_reason = AnthropicModelDriver.unavailable_reason
+maintainer = "Needs maintainer"
+
+
+class AnthropicProvider(LLMProvider):
+    name = "anthropic"
+    maintainer = "Needs maintainer"
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = "claude-3-opus-20240229"
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        if not self.available:
+            self._driver = None
+            return
+        self.auth_manager = auth_manager or LLMAuthManager()
+        self._api_key = self.auth_manager.get_credentials(type(self).name)
+        self._tools_adapter = LocalToolsAdapter()
+        self._info = config or LLMDriverConfig(model=None)
+        if not self._info.model:
+            self._info.model = self.DEFAULT_MODEL
+        if not self._info.api_key:
+            self._info.api_key = self._api_key
+        self.fill_missing_device_info(self._info)
+        self._driver = AnthropicModelDriver(tools_adapter=self._tools_adapter)
+
+    @property
+    def driver(self):
+        if not self.available:
+            raise ImportError(
+                f"AnthropicProvider unavailable: {self.unavailable_reason}"
+            )
+        return self._driver
+
+    @property
+    def available(self):
+        return available
+
+    @property
+    def unavailable_reason(self):
+        return unavailable_reason
+
+    def create_agent(self, tools_adapter=None, agent_name: str = None, **kwargs):
+        from janito.llm.agent import LLMAgent
+        from janito.drivers.anthropic.driver import AnthropicModelDriver
+
+        # Always create a new driver with the passed-in tools_adapter
+        driver = AnthropicModelDriver(tools_adapter=tools_adapter)
+        return LLMAgent(self, tools_adapter, agent_name=agent_name, **kwargs)
+
+
+LLMProviderRegistry.register(AnthropicProvider.name, AnthropicProvider)

janito/providers/azure_openai/model_info.py

@@ -0,0 +1,15 @@
+from janito.llm.model import LLMModelInfo
+
+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,
+        open="azure_openai",
+        driver="AzureOpenAIModelDriver",
+    )
+}

janito/providers/azure_openai/provider.py

@@ -0,0 +1,72 @@
+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.providers.registry import LLMProviderRegistry
+
+from .model_info import MODEL_SPECS
+
+from janito.drivers.azure_openai.driver import AzureOpenAIModelDriver
+
+available = AzureOpenAIModelDriver.available
+unavailable_reason = AzureOpenAIModelDriver.unavailable_reason
+maintainer = "João Pinto <lamego.pinto@gmail.com>"
+
+
+class AzureOpenAIProvider(LLMProvider):
+    name = "azure_openai"
+    maintainer = "João Pinto <lamego.pinto@gmail.com>"
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = "azure_openai_deployment"
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        if not self.available:
+            self._driver = None
+            return
+        self._auth_manager = auth_manager or LLMAuthManager()
+        self._api_key = self._auth_manager.get_credentials(type(self).name)
+        self._tools_adapter = LocalToolsAdapter()
+        self._driver_config = config or LLMDriverConfig(model=None)
+        if not self._driver_config.model:
+            self._driver_config.model = self.DEFAULT_MODEL
+        if not self._driver_config.api_key:
+            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"
+        self.fill_missing_device_info(self._driver_config)
+        self._driver = AzureOpenAIModelDriver(tools_adapter=self._tools_adapter)
+
+    @property
+    def driver(self):
+        if not self.available:
+            raise ImportError(
+                f"AzureOpenAIProvider unavailable: {self.unavailable_reason}"
+            )
+        return self._driver
+
+    @property
+    def available(self):
+        return available
+
+    @property
+    def unavailable_reason(self):
+        return unavailable_reason
+
+    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
+
+        # Always create a new driver with the passed-in tools_adapter
+        driver = AzureOpenAIModelDriver(tools_adapter=tools_adapter)
+        return LLMAgent(self, tools_adapter, agent_name=agent_name, **kwargs)
+
+    def execute_tool(self, tool_name: str, event_bus, *args, **kwargs):
+        # Use direct execution via adapter:
+        self._tools_adapter.event_bus = event_bus
+        return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
+
+
+LLMProviderRegistry.register(AzureOpenAIProvider.name, AzureOpenAIProvider)

janito/providers/deepseek/__init__.py

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

janito/providers/deepseek/model_info.py

@@ -0,0 +1,16 @@
+MODEL_SPECS = {
+    "deepseek-chat": {
+        "description": "DeepSeek Chat Model (OpenAI-compatible)",
+        "context_window": 8192,
+        "max_tokens": 4096,
+        "family": "deepseek",
+        "default": True,
+    },
+    "deepseek-coder": {
+        "description": "DeepSeek Coder Model (OpenAI-compatible)",
+        "context_window": 8192,
+        "max_tokens": 4096,
+        "family": "deepseek",
+        "default": False,
+    },
+}