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

janito/providers/deepseek/provider.py

@@ -0,0 +1,91 @@
+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.drivers.openai.driver import OpenAIModelDriver
+from janito.tools import get_local_tools_adapter
+from janito.providers.registry import LLMProviderRegistry
+from .model_info import MODEL_SPECS
+from queue import Queue
+
+available = OpenAIModelDriver.available
+unavailable_reason = OpenAIModelDriver.unavailable_reason
+
+
+class DeepseekProvider(LLMProvider):
+    name = "deepseek"
+    maintainer = "Needs maintainer"
+    MODEL_SPECS = MODEL_SPECS
+    DEFAULT_MODEL = "deepseek-chat"  # Options: deepseek-chat, deepseek-coder
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        if not self.available:
+            self._driver = None
+        else:
+            self.auth_manager = auth_manager or LLMAuthManager()
+            self._api_key = self.auth_manager.get_credentials(type(self).name)
+            self._tools_adapter = get_local_tools_adapter()
+            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
+            # Set DeepSeek public endpoint as default base_url if not provided
+            if not getattr(self._driver_config, "base_url", None):
+                self._driver_config.base_url = "https://api.deepseek.com/v1"
+            self.fill_missing_device_info(self._driver_config)
+            self._driver = None  # to be provided by factory/agent
+
+    @property
+    def driver(self) -> OpenAIModelDriver:
+        if not self.available:
+            raise ImportError(f"OpenAIProvider unavailable: {self.unavailable_reason}")
+        return self._driver
+
+    @property
+    def available(self):
+        return available
+
+    @property
+    def unavailable_reason(self):
+        return unavailable_reason
+
+    def create_driver(self):
+        """
+        Creates and returns a new OpenAIModelDriver instance with input/output queues.
+        """
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.name
+        )
+        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
+
+        # Always create a new driver with the passed-in tools_adapter
+        if tools_adapter is None:
+            tools_adapter = get_local_tools_adapter()
+        # Should use new-style driver construction via queues/factory (handled elsewhere)
+        raise NotImplementedError(
+            "create_agent must be constructed via new factory using input/output queues and config."
+        )
+
+    @property
+    def model_name(self):
+        return self._driver_config.model
+
+    @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):
+        self._tools_adapter.event_bus = event_bus
+        return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
+
+
+LLMProviderRegistry.register(DeepseekProvider.name, DeepseekProvider)

janito/providers/google/__init__.py

@@ -0,0 +1 @@
+from .provider import GoogleProvider

janito/providers/google/model_info.py

@@ -0,0 +1,40 @@
+from janito.llm.model import LLMModelInfo
+
+MODEL_SPECS = {
+    "gemini-2.5-pro-preview-05-06": LLMModelInfo(
+        name="gemini-2.5-pro-preview-05-06",
+        context=131072,
+        max_input=131072,
+        max_cot="N/A",
+        max_response=32768,
+        thinking_supported=True,
+        default_temp=0.2,
+        open="google",
+        driver="GoogleGenaiModelDriver",
+        other={"preview": True},
+    ),
+    "gemini-2.5-flash-preview-05-20": LLMModelInfo(
+        name="gemini-2.5-flash-preview-05-20",
+        context=1000000,
+        max_input=1000000,
+        max_cot="N/A",
+        max_response=65536,
+        thinking_supported=True,
+        default_temp=0.2,
+        open="google",
+        driver="GoogleGenaiModelDriver",
+        other={"preview": True, "flash": True},
+    ),
+    "gemini-2.5-flash-preview-04-17": LLMModelInfo(
+        name="gemini-2.5-flash-preview-04-17",
+        context=1000000,
+        max_input=1000000,
+        max_cot="N/A",
+        max_response=65536,
+        thinking_supported=True,
+        default_temp=0.2,
+        open="google",
+        driver="GoogleGenaiModelDriver",
+        other={"preview": True, "flash": True},
+    ),
+}

janito/providers/google/provider.py

@@ -0,0 +1,69 @@
+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.drivers.google_genai.driver import GoogleGenaiModelDriver
+from janito.tools.adapters.local.adapter import LocalToolsAdapter
+from janito.providers.registry import LLMProviderRegistry
+
+from .model_info import MODEL_SPECS
+
+from janito.drivers.google_genai.driver import GoogleGenaiModelDriver
+
+available = GoogleGenaiModelDriver.available
+unavailable_reason = GoogleGenaiModelDriver.unavailable_reason
+maintainer = "Needs maintainer"
+
+
+class GoogleProvider(LLMProvider):
+    MODEL_SPECS = MODEL_SPECS
+    maintainer = "Needs maintainer"
+    """
+    Provider for Google LLMs via google-google.
+    Default model: 'gemini-2.5-pro-preview-05-06'.
+    """
+    name = "google"
+    DEFAULT_MODEL = "gemini-2.5-flash-preview-04-17"
+
+    def __init__(self, config: LLMDriverConfig = None):
+        if not self.available:
+            self._driver = None
+            return
+        self._auth_manager = 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 = GoogleGenaiModelDriver(tools_adapter=self._tools_adapter)
+
+    @property
+    def driver(self) -> GoogleGenaiModelDriver:
+        if not self.available:
+            raise ImportError(f"GoogleProvider 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
+
+        # Always create a new driver with the passed-in tools_adapter
+        driver = GoogleGenaiModelDriver(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):
+        self._tools_adapter.event_bus = event_bus
+        return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
+
+
+LLMProviderRegistry.register(GoogleProvider.name, GoogleProvider)

janito/providers/mistralai/model_info.py

@@ -0,0 +1,37 @@
+from janito.llm.model import LLMModelInfo
+
+MODEL_SPECS = {
+    "mistral-medium-latest": LLMModelInfo(
+        name="mistral-medium-latest",
+        context=32000,
+        max_input=32000,
+        max_cot="N/A",
+        max_response=8192,
+        thinking_supported=True,
+        default_temp=0.2,
+        open="mistralai",
+        driver="MistralAIModelDriver",
+    ),
+    "mistral-large-latest": LLMModelInfo(
+        name="mistral-large-latest",
+        context=64000,
+        max_input=64000,
+        max_cot="N/A",
+        max_response=16384,
+        thinking_supported=True,
+        default_temp=0.2,
+        open="mistralai",
+        driver="MistralAIModelDriver",
+    ),
+    "mistral-small-latest": LLMModelInfo(
+        name="mistral-small-latest",
+        context=16000,
+        max_input=16000,
+        max_cot="N/A",
+        max_response=4096,
+        thinking_supported=False,
+        default_temp=0.2,
+        open="mistralai",
+        driver="MistralAIModelDriver",
+    ),
+}

janito/providers/mistralai/provider.py

@@ -0,0 +1,69 @@
+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.drivers.mistralai.driver import MistralAIModelDriver
+from janito.tools.adapters.local.adapter import LocalToolsAdapter
+from janito.providers.registry import LLMProviderRegistry
+
+from .model_info import MODEL_SPECS
+
+from janito.drivers.mistralai.driver import MistralAIModelDriver
+
+available = MistralAIModelDriver.available
+unavailable_reason = MistralAIModelDriver.unavailable_reason
+
+
+class MistralAIProvider(LLMProvider):
+    MODEL_SPECS = MODEL_SPECS
+    name = "mistralai"
+    maintainer = "Needs maintainer"
+
+    DEFAULT_MODEL = "mistral-medium-latest"
+
+    def __init__(
+        self, config: LLMDriverConfig = None, auth_manager: LLMAuthManager = 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 = MistralAIModelDriver(tools_adapter=self._tools_adapter)
+
+    @property
+    def driver(self):
+        if not self.available:
+            raise ImportError(
+                f"MistralAIProvider 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
+
+        # Always create a new driver with the passed-in tools_adapter
+        driver = MistralAIModelDriver(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):
+        self._tools_adapter.event_bus = event_bus
+        return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
+
+
+LLMProviderRegistry.register(MistralAIProvider.name, MistralAIProvider)

janito/providers/openai/__init__.py

@@ -0,0 +1 @@
+from .provider import OpenAIProvider

janito/providers/openai/model_info.py

@@ -0,0 +1,137 @@
+from janito.llm.model import LLMModelInfo
+
+MODEL_SPECS = {
+    "gpt-3.5-turbo": LLMModelInfo(
+        name="gpt-3.5-turbo",
+        context=16385,
+        max_input=12289,
+        max_cot="N/A",
+        max_response=4096,
+        thinking_supported=False,
+        default_temp=0.2,
+        open="openai",
+        driver="OpenAIModelDriver",
+    ),
+    "gpt-4.1": LLMModelInfo(
+        name="gpt-4.1",
+        context=1047576,
+        max_input=1014808,
+        max_cot="N/A",
+        max_response=32768,
+        thinking_supported=False,
+        default_temp=0.2,
+        open="openai",
+        driver="OpenAIModelDriver",
+    ),
+    "gpt-4.1-mini": LLMModelInfo(
+        name="gpt-4.1-mini",
+        context=1047576,
+        max_input=1014808,
+        max_cot="N/A",
+        max_response=32768,
+        thinking_supported=False,
+        default_temp=0.2,
+        open="openai",
+        driver="OpenAIModelDriver",
+    ),
+    "gpt-4.1-nano": LLMModelInfo(
+        name="gpt-4.1-nano",
+        context=1047576,
+        max_input=1014808,
+        max_cot="N/A",
+        max_response=32768,
+        thinking_supported=False,
+        default_temp=0.2,
+        open="openai",
+        driver="OpenAIModelDriver",
+    ),
+    "gpt-4-turbo": LLMModelInfo(
+        name="gpt-4-turbo",
+        context=128000,
+        max_input="N/A",
+        max_cot="N/A",
+        max_response="N/A",
+        thinking_supported=False,
+        default_temp=0.2,
+        open="openai",
+        driver="OpenAIModelDriver",
+    ),
+    "gpt-4o": LLMModelInfo(
+        name="gpt-4o",
+        context=128000,
+        max_input=123904,
+        max_cot="N/A",
+        max_response=4096,
+        thinking_supported=False,
+        default_temp=0.2,
+        open="openai",
+        driver="OpenAIModelDriver",
+    ),
+    "gpt-4o-mini": LLMModelInfo(
+        name="gpt-4o-mini",
+        context=128000,
+        max_input=111616,
+        max_cot="N/A",
+        max_response=16384,
+        thinking_supported=False,
+        default_temp=0.2,
+        open="openai",
+        driver="OpenAIModelDriver",
+    ),
+    "o3-mini": LLMModelInfo(
+        name="o3-mini",
+        context=200000,
+        max_input=100000,
+        max_cot="N/A",
+        max_response=100000,
+        thinking_supported=True,
+        default_temp=1.0,
+        open="openai",
+        driver="OpenAIModelDriver",
+    ),
+    "o3": LLMModelInfo(
+        name="o3",
+        context=200000,
+        max_input=100000,
+        max_cot="N/A",
+        max_response=100000,
+        thinking_supported=True,
+        default_temp=1.0,
+        open="openai",
+        driver="OpenAIModelDriver",
+    ),
+    "o4-mini": LLMModelInfo(
+        name="o4-mini",
+        context=200000,
+        max_input=100000,
+        max_cot="N/A",
+        max_response=100000,
+        thinking_supported=True,
+        default_temp=1.0,
+        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",
+        context=128000,
+        max_input="N/A",
+        max_cot="N/A",
+        max_response="N/A",
+        thinking_supported=False,
+        default_temp=0.2,
+        open="openai",
+        driver="OpenAIModelDriver",
+    ),
+}

janito/providers/openai/provider.py

@@ -0,0 +1,107 @@
+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.drivers.openai.driver import OpenAIModelDriver
+from janito.tools import get_local_tools_adapter
+from janito.providers.registry import LLMProviderRegistry
+from .model_info import MODEL_SPECS
+from queue import Queue
+
+available = OpenAIModelDriver.available
+unavailable_reason = OpenAIModelDriver.unavailable_reason
+
+
+class OpenAIProvider(LLMProvider):
+    name = "openai"
+    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
+    )
+
+    def __init__(
+        self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
+    ):
+        if not self.available:
+            self._driver = None
+        else:
+            self.auth_manager = auth_manager or LLMAuthManager()
+            self._api_key = self.auth_manager.get_credentials(type(self).name)
+            self._tools_adapter = get_local_tools_adapter()
+            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
+            # Set only the correct token parameter for the model
+            model_name = self._driver_config.model
+            model_spec = self.MODEL_SPECS.get(model_name)
+            # Remove both to avoid stale values
+            if hasattr(self._driver_config, "max_tokens"):
+                self._driver_config.max_tokens = None
+            if hasattr(self._driver_config, "max_completion_tokens"):
+                self._driver_config.max_completion_tokens = None
+            if model_spec:
+                if getattr(model_spec, "thinking_supported", False):
+                    max_cot = getattr(model_spec, "max_cot", None)
+                    if max_cot and max_cot != "N/A":
+                        self._driver_config.max_completion_tokens = int(max_cot)
+                else:
+                    max_response = getattr(model_spec, "max_response", None)
+                    if max_response and max_response != "N/A":
+                        self._driver_config.max_tokens = int(max_response)
+            self.fill_missing_device_info(self._driver_config)
+            self._driver = None  # to be provided by factory/agent
+
+    @property
+    def driver(self) -> OpenAIModelDriver:
+        if not self.available:
+            raise ImportError(f"OpenAIProvider unavailable: {self.unavailable_reason}")
+        return self._driver
+
+    @property
+    def available(self):
+        return available
+
+    @property
+    def unavailable_reason(self):
+        return unavailable_reason
+
+    def create_driver(self):
+        """
+        Creates and returns a new OpenAIModelDriver instance with input/output queues.
+        """
+        driver = OpenAIModelDriver(
+            tools_adapter=self._tools_adapter, provider_name=self.name
+        )
+        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
+
+        # Always create a new driver with the passed-in tools_adapter
+        if tools_adapter is None:
+            tools_adapter = get_local_tools_adapter()
+        # Should use new-style driver construction via queues/factory (handled elsewhere)
+        raise NotImplementedError(
+            "create_agent must be constructed via new factory using input/output queues and config."
+        )
+
+    @property
+    def model_name(self):
+        return self._driver_config.model
+
+    @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):
+        self._tools_adapter.event_bus = event_bus
+        return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
+
+
+LLMProviderRegistry.register(OpenAIProvider.name, OpenAIProvider)

janito/providers/openai/schema_generator.py

@@ -0,0 +1,63 @@
+import inspect
+import typing
+from collections import OrderedDict
+from typing import List
+from janito.tools.tools_schema import ToolSchemaBase
+
+
+class OpenAISchemaGenerator(ToolSchemaBase):
+    PYTHON_TYPE_TO_JSON = {
+        str: "string",
+        int: "integer",
+        float: "number",
+        bool: "boolean",
+        list: "array",
+        dict: "object",
+    }
+
+    def type_to_json_schema(self, annotation):
+        if hasattr(annotation, "__origin__"):
+            if annotation.__origin__ is list or annotation.__origin__ is typing.List:
+                return {
+                    "type": "array",
+                    "items": self.type_to_json_schema(annotation.__args__[0]),
+                }
+            if annotation.__origin__ is dict or annotation.__origin__ is typing.Dict:
+                return {"type": "object"}
+        return {"type": self.PYTHON_TYPE_TO_JSON.get(annotation, "string")}
+
+    def generate_schema(self, tool_class):
+        # DEBUG: Print class and .name for trace
+        func, tool_name, sig, summary, param_descs, return_desc, description = (
+            self.validate_tool_class(tool_class)
+        )
+        properties = OrderedDict()
+        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_json_schema(annotation)
+            schema["description"] = pdesc
+            properties[name] = schema
+            if param.default == inspect._empty:
+                required.append(name)
+        return {
+            "name": tool_name,
+            "description": description,
+            "parameters": {
+                "type": "object",
+                "properties": properties,
+                "required": required,
+            },
+        }
+
+
+def generate_tool_schemas(tool_classes: List[type]):
+    generator = OpenAISchemaGenerator()
+    return [
+        {"type": "function", "function": generator.generate_schema(tool_class)}
+        for tool_class in tool_classes
+    ]

janito/providers/provider_static_info.py

@@ -0,0 +1,21 @@
+# Provider static metadata registry for listing purposes (name, maintainer, and future fields)
+STATIC_PROVIDER_METADATA = {
+    "openai": {
+        "maintainer": "João Pinto <lamego.pinto@gmail.com>",
+    },
+    "azure_openai": {
+        "maintainer": "João Pinto <lamego.pinto@gmail.com>",
+    },
+    "google": {
+        "maintainer": "Needs maintainer",
+    },
+    "mistralai": {
+        "maintainer": "Needs maintainer",
+    },
+    "anthropic": {
+        "maintainer": "Needs maintainer",
+    },
+    "deepseek": {
+        "maintainer": "João Pinto <lamego.pinto@gmail.com>",
+    },
+}

janito/providers/registry.py

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