janito 1.14.3__py3-none-any.whl → 2.0.1__py3-none-any.whl

janito/drivers/google_genai/driver.py

@@ -0,0 +1,54 @@
+"""
+Google Gemini LLM driver.
+
+This driver handles interaction with the Google Gemini API, including support for tool/function calls and event publishing.
+"""
+
+import json
+import time
+import uuid
+import traceback
+from typing import Optional, List, Dict, Any, Union
+from janito.llm.driver import LLMDriver
+from janito.drivers.google_genai.schema_generator import generate_tool_declarations
+from janito.driver_events import (
+    GenerationStarted,
+    GenerationFinished,
+    RequestStarted,
+    RequestFinished,
+    ResponseReceived,
+    RequestStatus,
+)
+from janito.tools.adapters.local.adapter import LocalToolsAdapter
+from janito.llm.message_parts import TextMessagePart, FunctionCallMessagePart
+from janito.llm.driver_config import LLMDriverConfig
+
+
+def extract_usage_metadata_native(usage_obj):
+    if usage_obj is None:
+        return {}
+    result = {}
+    for attr in dir(usage_obj):
+        if attr.startswith("_") or attr == "__class__":
+            continue
+        value = getattr(usage_obj, attr)
+        if isinstance(value, (str, int, float, bool, type(None))):
+            result[attr] = value
+        elif isinstance(value, list):
+            if all(isinstance(i, (str, int, float, bool, type(None))) for i in value):
+                result[attr] = value
+    return result
+
+
+class GoogleGenaiModelDriver(LLMDriver):
+    available = False
+    unavailable_reason = "GoogleGenaiModelDriver is not implemented yet."
+
+    @classmethod
+    def is_available(cls):
+        return cls.available
+
+    name = "google_genai"
+
+    def __init__(self, tools_adapter=None):
+        raise ImportError(self.unavailable_reason)

janito/drivers/google_genai/schema_generator.py

@@ -0,0 +1,67 @@
+import inspect
+import typing
+from janito.tools.tools_schema import ToolSchemaBase
+
+try:
+    from google.genai import types as genai_types
+except ImportError:
+    genai_types = None
+
+
+class GeminiSchemaGenerator(ToolSchemaBase):
+    PYTHON_TYPE_TO_GENAI_TYPE = {
+        str: "STRING",
+        int: "INTEGER",
+        float: "NUMBER",
+        bool: "BOOLEAN",
+        list: "ARRAY",
+        dict: "OBJECT",
+    }
+
+    def type_to_genai_schema(self, annotation, description=None):
+        if hasattr(annotation, "__origin__"):
+            if annotation.__origin__ is list or annotation.__origin__ is typing.List:
+                return genai_types.Schema(
+                    type="ARRAY",
+                    items=self.type_to_genai_schema(annotation.__args__[0]),
+                    description=description,
+                )
+            if annotation.__origin__ is dict or annotation.__origin__ is typing.Dict:
+                return genai_types.Schema(type="OBJECT", description=description)
+        return genai_types.Schema(
+            type=self.PYTHON_TYPE_TO_GENAI_TYPE.get(annotation, "STRING"),
+            description=description,
+        )
+
+    def generate_declaration(self, tool_class):
+        func, tool_name, sig, summary, param_descs, return_desc, description = (
+            self.validate_tool_class(tool_class)
+        )
+        properties = {}
+        required = []
+        # Removed tool_call_reason from properties and required
+        for name, param in sig.parameters.items():
+            if name == "self":
+                continue
+            annotation = param.annotation
+            pdesc = param_descs.get(name, "")
+            schema = self.type_to_genai_schema(annotation, description=pdesc)
+            properties[name] = schema
+            if param.default == inspect._empty:
+                required.append(name)
+        parameters_schema = genai_types.Schema(
+            type="OBJECT", properties=properties, required=required
+        )
+        return genai_types.FunctionDeclaration(
+            name=tool_name, description=description, parameters=parameters_schema
+        )
+
+
+def generate_tool_declarations(tool_classes: list):
+    if genai_types is None:
+        raise ImportError("google-genai package is not installed.")
+    generator = GeminiSchemaGenerator()
+    function_declarations = [
+        generator.generate_declaration(tool_class) for tool_class in tool_classes
+    ]
+    return [genai_types.Tool(function_declarations=function_declarations)]

janito/drivers/mistralai/driver.py

@@ -0,0 +1,41 @@
+import time
+import uuid
+import traceback
+import json
+from typing import Optional, List, Dict, Any, Union
+from janito.llm.driver import LLMDriver
+from janito.driver_events import (
+    GenerationStarted,
+    GenerationFinished,
+    RequestStarted,
+    RequestFinished,
+    ResponseReceived,
+)
+from janito.providers.openai.schema_generator import generate_tool_schemas
+from janito.tools.adapters.local.adapter import LocalToolsAdapter
+from janito.llm.message_parts import TextMessagePart, FunctionCallMessagePart
+from janito.llm.driver_config import LLMDriverConfig
+
+# Safe import of mistralai SDK
+try:
+    from mistralai import Mistral
+
+    DRIVER_AVAILABLE = True
+    DRIVER_UNAVAILABLE_REASON = None
+except ImportError:
+    DRIVER_AVAILABLE = False
+    DRIVER_UNAVAILABLE_REASON = "Missing dependency: mistralai (pip install mistralai)"
+
+
+class MistralAIModelDriver(LLMDriver):
+    available = False
+    unavailable_reason = "MistralAIModelDriver is not implemented yet."
+
+    @classmethod
+    def is_available(cls):
+        return cls.available
+
+    name = "mistralai"
+
+    def __init__(self, tools_adapter=None):
+        raise ImportError(self.unavailable_reason)

janito/drivers/openai/driver.py

@@ -0,0 +1,334 @@
+import uuid
+import traceback
+from rich import pretty
+from janito.llm.driver import LLMDriver
+from janito.llm.driver_input import DriverInput
+from janito.driver_events import RequestFinished, RequestStatus
+
+# Safe import of openai SDK
+try:
+    import openai
+
+    DRIVER_AVAILABLE = True
+    DRIVER_UNAVAILABLE_REASON = None
+except ImportError:
+    DRIVER_AVAILABLE = False
+    DRIVER_UNAVAILABLE_REASON = "Missing dependency: openai (pip install openai)"
+
+
+class OpenAIModelDriver(LLMDriver):
+    def _get_message_from_result(self, result):
+        """Extract the message object from the provider result (OpenAI-specific)."""
+        if hasattr(result, "choices") and result.choices:
+            return result.choices[0].message
+        return None
+
+    """
+    OpenAI LLM driver (threaded, queue-based, stateless). Uses input/output queues accessible via instance attributes.
+    """
+    available = DRIVER_AVAILABLE
+    unavailable_reason = DRIVER_UNAVAILABLE_REASON
+
+    def __init__(self, tools_adapter=None, provider_name=None):
+        super().__init__(tools_adapter=tools_adapter, provider_name=provider_name)
+
+    def _prepare_api_kwargs(self, config, conversation):
+        """
+        Prepares API kwargs for OpenAI, including tool schemas if tools_adapter is present,
+        and OpenAI-specific arguments (model, max_tokens, temperature, etc.).
+        """
+        api_kwargs = {}
+        # Tool schemas (moved from base)
+        if self.tools_adapter:
+            try:
+                from janito.providers.openai.schema_generator import (
+                    generate_tool_schemas,
+                )
+
+                tool_classes = self.tools_adapter.get_tool_classes()
+                tool_schemas = generate_tool_schemas(tool_classes)
+                api_kwargs["tools"] = tool_schemas
+            except Exception as e:
+                api_kwargs["tools"] = []
+                if hasattr(config, "verbose_api") and config.verbose_api:
+                    print(f"[OpenAIModelDriver] Tool schema generation failed: {e}")
+        # OpenAI-specific parameters
+        if config.model:
+            api_kwargs["model"] = config.model
+        # Prefer max_completion_tokens if present, else fallback to max_tokens (for backward compatibility)
+        if (
+            hasattr(config, "max_completion_tokens")
+            and config.max_completion_tokens is not None
+        ):
+            api_kwargs["max_completion_tokens"] = int(config.max_completion_tokens)
+        elif hasattr(config, "max_tokens") and config.max_tokens is not None:
+            # For models that do not support 'max_tokens', map to 'max_completion_tokens'
+            api_kwargs["max_completion_tokens"] = int(config.max_tokens)
+        for p in (
+            "temperature",
+            "top_p",
+            "presence_penalty",
+            "frequency_penalty",
+            "stop",
+        ):
+            v = getattr(config, p, None)
+            if v is not None:
+                api_kwargs[p] = v
+        api_kwargs["messages"] = conversation
+        api_kwargs["stream"] = False
+        return api_kwargs
+
+    def _call_api(self, driver_input: DriverInput):
+        cancel_event = getattr(driver_input, "cancel_event", None)
+        config = driver_input.config
+        conversation = self.convert_history_to_api_messages(
+            driver_input.conversation_history
+        )
+        request_id = getattr(config, "request_id", None)
+        if config.verbose_api:
+            print(
+                f"[verbose-api] OpenAI API call about to be sent. Model: {config.model}, max_tokens: {config.max_tokens}, tools_adapter: {type(self.tools_adapter).__name__ if self.tools_adapter else None}",
+                flush=True,
+            )
+        try:
+            client = self._instantiate_openai_client(config)
+            api_kwargs = self._prepare_api_kwargs(config, conversation)
+            if config.verbose_api:
+                print(
+                    f"[OpenAI] API CALL: chat.completions.create(**{api_kwargs})",
+                    flush=True,
+                )
+            if self._check_cancel(cancel_event, request_id, before_call=True):
+                return None
+            result = client.chat.completions.create(**api_kwargs)
+            if self._check_cancel(cancel_event, request_id, before_call=False):
+                return None
+            self._print_verbose_result(config, result)
+            usage_dict = self._extract_usage(result)
+            if config.verbose_api:
+                print(
+                    f"[OpenAI][DEBUG] Attaching usage info to RequestFinished: {usage_dict}",
+                    flush=True,
+                )
+            self.output_queue.put(
+                RequestFinished(
+                    driver_name=self.__class__.__name__,
+                    request_id=request_id,
+                    response=result,
+                    status=RequestStatus.SUCCESS,
+                    usage=usage_dict,
+                )
+            )
+            if config.verbose_api:
+                pretty.install()
+                print("[OpenAI] API RESPONSE:", flush=True)
+                pretty.pprint(result)
+            return result
+        except Exception as e:
+            print(f"[ERROR] Exception during OpenAI API call: {e}", flush=True)
+            print(f"[ERROR] config: {config}", flush=True)
+            print(
+                f"[ERROR] api_kwargs: {api_kwargs if 'api_kwargs' in locals() else 'N/A'}",
+                flush=True,
+            )
+            import traceback
+
+            print("[ERROR] Full stack trace:", flush=True)
+            print(traceback.format_exc(), flush=True)
+            raise
+
+    def _instantiate_openai_client(self, config):
+        try:
+            api_key_display = str(config.api_key)
+            if api_key_display and len(api_key_display) > 8:
+                api_key_display = api_key_display[:4] + "..." + api_key_display[-4:]
+            client_kwargs = {"api_key": config.api_key}
+            if getattr(config, "base_url", None):
+                client_kwargs["base_url"] = config.base_url
+            client = openai.OpenAI(**client_kwargs)
+            return client
+        except Exception as e:
+            print(
+                f"[ERROR] Exception during OpenAI client instantiation: {e}", flush=True
+            )
+            import traceback
+
+            print(traceback.format_exc(), flush=True)
+            raise
+
+    def _check_cancel(self, cancel_event, request_id, before_call=True):
+        if cancel_event is not None and cancel_event.is_set():
+            status = RequestStatus.CANCELLED
+            reason = (
+                "Cancelled before API call"
+                if before_call
+                else "Cancelled during API call"
+            )
+            self.output_queue.put(
+                RequestFinished(
+                    driver_name=self.__class__.__name__,
+                    request_id=request_id,
+                    status=status,
+                    reason=reason,
+                )
+            )
+            return True
+        return False
+
+    def _print_verbose_result(self, config, result):
+        if config.verbose_api:
+            print("[OpenAI] API RAW RESULT:", flush=True)
+            pretty.pprint(result)
+            if hasattr(result, "__dict__"):
+                print("[OpenAI] API RESULT __dict__:", flush=True)
+                pretty.pprint(result.__dict__)
+            try:
+                print("[OpenAI] API RESULT as dict:", dict(result), flush=True)
+            except Exception:
+                pass
+            print(
+                f"[OpenAI] API RESULT .usage: {getattr(result, 'usage', None)}",
+                flush=True,
+            )
+            try:
+                print(f"[OpenAI] API RESULT ['usage']: {result['usage']}", flush=True)
+            except Exception:
+                pass
+            if not hasattr(result, "usage") or getattr(result, "usage", None) is None:
+                print(
+                    "[OpenAI][WARNING] No usage info found in API response.", flush=True
+                )
+
+    def _extract_usage(self, result):
+        usage = getattr(result, "usage", None)
+        if usage is not None:
+            usage_dict = self._usage_to_dict(usage)
+            if usage_dict is None:
+                print(
+                    "[OpenAI][WARNING] Could not convert usage to dict, using string fallback.",
+                    flush=True,
+                )
+                usage_dict = str(usage)
+        else:
+            usage_dict = self._extract_usage_from_result_dict(result)
+        return usage_dict
+
+    def _usage_to_dict(self, usage):
+        if hasattr(usage, "model_dump") and callable(getattr(usage, "model_dump")):
+            try:
+                return usage.model_dump()
+            except Exception:
+                pass
+        if hasattr(usage, "dict") and callable(getattr(usage, "dict")):
+            try:
+                return usage.dict()
+            except Exception:
+                pass
+        try:
+            return dict(usage)
+        except Exception:
+            try:
+                return vars(usage)
+            except Exception:
+                pass
+        return None
+
+    def _extract_usage_from_result_dict(self, result):
+        try:
+            return result["usage"]
+        except Exception:
+            return None
+
+    def convert_history_to_api_messages(self, conversation_history):
+        """
+        Convert LLMConversationHistory to the list of dicts required by OpenAI's API.
+        Handles 'tool_results' and 'tool_calls' roles for compliance.
+        """
+        import json
+
+        api_messages = []
+        for msg in conversation_history.get_history():
+            role = msg.get("role")
+            content = msg.get("content")
+            if role == "tool_results":
+                # Expect content to be a list of tool result dicts or a stringified list
+                try:
+                    results = (
+                        json.loads(content) if isinstance(content, str) else content
+                    )
+                except Exception:
+                    results = [content]
+                for result in results:
+                    # result should be a dict with keys: name, content, tool_call_id
+                    if isinstance(result, dict):
+                        api_messages.append(
+                            {
+                                "role": "tool",
+                                "content": result.get("content", ""),
+                                "name": result.get("name", ""),
+                                "tool_call_id": result.get("tool_call_id", ""),
+                            }
+                        )
+                    else:
+                        api_messages.append(
+                            {
+                                "role": "tool",
+                                "content": str(result),
+                                "name": "",
+                                "tool_call_id": "",
+                            }
+                        )
+            elif role == "tool_calls":
+                # Convert to assistant message with tool_calls field
+                import json
+
+                try:
+                    tool_calls = (
+                        json.loads(content) if isinstance(content, str) else content
+                    )
+                except Exception:
+                    tool_calls = []
+                api_messages.append(
+                    {"role": "assistant", "content": None, "tool_calls": tool_calls}
+                )
+            else:
+                # Special handling for 'function' role: extract 'name' from metadata if present
+                if role == "function":
+                    name = ""
+                    if isinstance(msg, dict):
+                        metadata = msg.get("metadata", {})
+                        name = (
+                            metadata.get("name", "")
+                            if isinstance(metadata, dict)
+                            else ""
+                        )
+                    api_messages.append(
+                        {"role": "tool", "content": content, "name": name}
+                    )
+                else:
+                    api_messages.append(msg)
+        return api_messages
+
+    def _convert_completion_message_to_parts(self, message):
+        """
+        Convert an OpenAI completion message object to a list of MessagePart objects.
+        Handles text, tool calls, and can be extended for other types.
+        """
+        from janito.llm.message_parts import TextMessagePart, FunctionCallMessagePart
+
+        parts = []
+        # Text content
+        content = getattr(message, "content", None)
+        if content:
+            parts.append(TextMessagePart(content=content))
+        # Tool calls
+        tool_calls = getattr(message, "tool_calls", None) or []
+        for tool_call in tool_calls:
+            parts.append(
+                FunctionCallMessagePart(
+                    tool_call_id=getattr(tool_call, "id", ""),
+                    function=getattr(tool_call, "function", None),
+                )
+            )
+        # Extend here for other message part types if needed
+        return parts

janito/event_bus/__init__.py

@@ -0,0 +1,2 @@
+from .bus import EventBus, event_bus
+from .handler import EventHandlerBase

janito/event_bus/bus.py

@@ -0,0 +1,68 @@
+from collections import defaultdict
+from datetime import datetime
+from bisect import insort
+import itertools
+import threading
+
+
+class EventBus:
+    """
+    Generic event bus for publish/subscribe event-driven communication with handler priorities.
+    Automatically injects a timestamp (event.timestamp) into each event when published.
+    Handlers with lower priority numbers are called first (default priority=100).
+    Thread-safe for concurrent subscribe, unsubscribe, and publish operations.
+    """
+
+    def __init__(self):
+        # _subscribers[event_type] = list of (priority, seq, callback)
+        self._subscribers = defaultdict(list)
+        self._seq_counter = itertools.count()
+        self._lock = threading.Lock()
+
+    def subscribe(self, event_type, callback, priority=100):
+        """Subscribe a callback to a specific event type with a given priority (lower is higher priority)."""
+        with self._lock:
+            seq = next(self._seq_counter)
+            entry = (priority, seq, callback)
+            callbacks = self._subscribers[event_type]
+            # Prevent duplicate subscriptions of the same callback with the same priority
+            if not any(
+                cb == callback and prio == priority for prio, _, cb in callbacks
+            ):
+                insort(callbacks, entry)
+
+    def unsubscribe(self, event_type, callback):
+        """Unsubscribe a callback from a specific event type (all priorities)."""
+        with self._lock:
+            callbacks = self._subscribers[event_type]
+            self._subscribers[event_type] = [
+                entry for entry in callbacks if entry[2] != callback
+            ]
+
+    def publish(self, event):
+        """
+        Publish an event to all relevant subscribers in strict priority order.
+        Thread-safe: handlers are called outside the lock to avoid deadlocks.
+        """
+        with self._lock:
+            # Collect all matching handlers (priority, seq, callback) for this event
+            matching_handlers = []
+            for event_type, callbacks in self._subscribers.items():
+                if isinstance(event, event_type):
+                    matching_handlers.extend(callbacks)
+            # Remove duplicates (same callback for same event)
+            seen = set()
+            unique_handlers = []
+            for prio, seq, cb in matching_handlers:
+                if cb not in seen:
+                    unique_handlers.append((prio, seq, cb))
+                    seen.add(cb)
+            # Sort by priority, then sequence
+            unique_handlers.sort()
+        # Call handlers outside the lock to avoid deadlocks
+        for priority, seq, callback in unique_handlers:
+            callback(event)
+
+
+# Singleton instance for global use
+event_bus = EventBus()

janito/event_bus/event.py

@@ -0,0 +1,15 @@
+import attr
+from typing import ClassVar
+from datetime import datetime
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class Event:
+    """
+    Base class for all events in the system.
+    Represents a generic event with a category.
+    Automatically sets a timestamp at creation.
+    """
+
+    category: ClassVar[str] = "generic"
+    timestamp: datetime = attr.ib(factory=datetime.utcnow)

janito/event_bus/handler.py

@@ -0,0 +1,31 @@
+import inspect
+from .bus import event_bus
+
+
+class EventHandlerBase:
+    """
+    Base class for event handler classes.
+    Automatically subscribes methods named on_<EventClassName> to the event bus for the corresponding event type.
+    Pass one or more event modules (e.g., janito.report_events, janito.driver_events) to the constructor.
+    Raises an error if a handler method does not match any known event class.
+    """
+
+    def __init__(self, *event_modules):
+        unknown_event_methods = []
+        for name, method in inspect.getmembers(self, predicate=inspect.ismethod):
+            if name.startswith("on_"):
+                event_class_name = name[3:]
+                event_class = None
+                for module in event_modules:
+                    event_class = getattr(module, event_class_name, None)
+                    if event_class:
+                        break
+                if event_class:
+                    event_bus.subscribe(event_class, method)
+                else:
+                    unknown_event_methods.append(name)
+        if unknown_event_methods:
+            raise ValueError(
+                f"Unknown event handler methods found: {unknown_event_methods}. "
+                f"No matching event class found in provided event modules."
+            )

janito/event_bus/queue_bus.py

@@ -0,0 +1,57 @@
+import threading
+import queue
+
+
+class QueueEventBusSentinel:
+    """
+    Special event to signal the end of event publishing for QueueEventBus.
+    """
+
+    pass
+
+
+class QueueEventBus:
+    """
+    Event bus using a single queue for event delivery, preserving event order.
+    API-compatible with EventBus for publish/subscribe, but all events go into one queue.
+    Thread-safe for concurrent publish operations.
+    """
+
+    def __init__(self):
+        self._queue = queue.Queue()
+        self._lock = threading.Lock()
+
+    def subscribe(self, event_type=None, event_queue=None, priority=100):
+        """
+        No-op for compatibility. Returns the single event queue.
+        """
+        return self._queue
+
+    def unsubscribe(self, event_type=None, event_queue=None):
+        """
+        No-op for compatibility.
+        """
+        pass
+
+    def publish(self, event):
+        """
+        Publish an event to the single queue.
+        """
+        with self._lock:
+            self._queue.put(event)
+
+    def get_queue(self):
+        """
+        Return the single event queue for consumers.
+        """
+        return self._queue
+
+    def fetch_event(self, block=True, timeout=None):
+        """
+        Fetch the next event from the queue. Blocks by default.
+        Returns None if a QueueEventBusSentinel is encountered.
+        """
+        event = self._queue.get(block=block, timeout=timeout)
+        if isinstance(event, QueueEventBusSentinel):
+            return None
+        return event