janito 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

janito/__init__.py

@@ -1 +1 @@
-__version__ = "1.2.1"
+__version__ = "1.3.0"

janito/agent/agent.py

@@ -7,7 +7,7 @@ from janito.agent.conversation import ConversationHandler
 from janito.agent.tool_handler import ToolHandler
 
 class Agent:
-    """LLM Agent capable of handling conversations and tool calls."""
+    """Agent capable of handling conversations and tool calls."""
 
     REFERER = "www.janito.dev"
     TITLE = "Janito"
@@ -19,10 +19,22 @@ class Agent:
         system_prompt: str | None = None,
         verbose_tools: bool = False,
         tool_handler = None,
-        base_url: str = "https://openrouter.ai/api/v1"
+        base_url: str = "https://openrouter.ai/api/v1",
+        azure_openai_api_version: str = "2023-05-15",
+        use_azure_openai: bool = False
     ):
         """
-        Initialize the Agent.
+        Initialize Agent,
+
+        Args:
+            api_key: API key for OpenAI-compatible service.
+            model: Model name to use.
+            system_prompt: Optional system prompt override.
+            verbose_tools: Enable verbose tool call logging.
+            tool_handler: Optional custom ToolHandler instance.
+            base_url: API base URL.
+            azure_openai_api_version: Azure OpenAI API version (default: "2023-05-15").
+            use_azure_openai: Whether to use Azure OpenAI client (default: False).
 
         Args:
             api_key: API key for OpenAI-compatible service.
@@ -35,12 +47,12 @@ class Agent:
         self.api_key = api_key
         self.model = model
         self.system_prompt = system_prompt
-        if os.environ.get("USE_AZURE_OPENAI"):
+        if use_azure_openai:
             from openai import AzureOpenAI
             self.client = AzureOpenAI(
                 api_key=api_key,
-                azure_endpoint=os.environ.get("AZURE_OPENAI_ENDPOINT"),
-                api_version=os.environ.get("AZURE_OPENAI_API_VERSION", "2023-05-15"),
+                azure_endpoint=base_url,
+                api_version=azure_openai_api_version,
             )
         else:
             self.client = OpenAI(
@@ -64,7 +76,7 @@ class Agent:
     def usage_history(self):
         return self.conversation_handler.usage_history
 
-    def chat(self, messages, on_content=None, on_tool_progress=None, verbose_response=False, spinner=False, max_tokens=None):
+    def chat(self, messages, on_content=None, on_tool_progress=None, verbose_response=False, spinner=False, max_tokens=None, max_rounds=50):
         import time
         from janito.agent.conversation import ProviderError
 
@@ -73,11 +85,12 @@ class Agent:
             try:
                 return self.conversation_handler.handle_conversation(
                     messages,
-                    max_tokens=max_tokens,
+                    max_rounds=max_rounds,
                     on_content=on_content,
                     on_tool_progress=on_tool_progress,
                     verbose_response=verbose_response,
-                    spinner=spinner
+                    spinner=spinner,
+                    max_tokens=max_tokens
                 )
             except ProviderError as e:
                 error_data = getattr(e, 'error_data', {}) or {}
@@ -96,5 +109,5 @@ class Agent:
                 else:
                     print("Max retries reached. Raising error.")
                     raise
-            except Exception:
+
                 raise

janito/agent/config.py

@@ -40,14 +40,12 @@ class FileConfig(BaseConfig):
 
     def load(self):
         if self.path.exists():
-            try:
-                with open(self.path, 'r') as f:
-                    self._data = json.load(f)
-                    # Remove keys with value None (null in JSON)
-                    self._data = {k: v for k, v in self._data.items() if v is not None}
-            except Exception as e:
-                print(f"Warning: Failed to load config file {self.path}: {e}")
-                self._data = {}
+            with open(self.path, 'r') as f:
+                self._data = json.load(f)
+                # Remove keys with value None (null in JSON)
+                self._data = {k: v for k, v in self._data.items() if v is not None}
+
+
         else:
             self._data = {}
 
@@ -57,6 +55,7 @@ class FileConfig(BaseConfig):
             json.dump(self._data, f, indent=2)
 
 
+
 CONFIG_OPTIONS = {
     "api_key": "API key for OpenAI-compatible service (required)",
     "model": "Model name to use (e.g., 'openai/gpt-4.1')",
@@ -64,9 +63,38 @@ CONFIG_OPTIONS = {
     "role": "Role description for the system prompt (e.g., 'software engineer')",
     "system_prompt": "Override the entire system prompt text",
     "temperature": "Sampling temperature (float, e.g., 0.0 - 2.0)",
-    "max_tokens": "Maximum tokens for model response (int)"
+    "max_tokens": "Maximum tokens for model response (int)",
+    # Accept template.* keys as valid config keys (for CLI validation, etc.)
+    "template": "Template context dictionary for prompt rendering (nested)",
+    # Note: template.* keys are validated dynamically, not statically here
 }
 
+class BaseConfig:
+    def __init__(self):
+        self._data = {}
+
+    def get(self, key, default=None):
+        return self._data.get(key, default)
+
+    def set(self, key, value):
+        self._data[key] = value
+
+    def all(self):
+        return self._data
+
+
+        """
+        Returns a dictionary suitable for passing as Jinja2 template variables.
+        Merges the nested 'template' dict (if present) and all flat 'template.*' keys.
+        Flat keys override nested dict keys if there is a conflict.
+        """
+        template_vars = dict(self._data.get("template", {}))
+        for k, v in self._data.items():
+            if k.startswith("template.") and k != "template":
+                template_vars[k[9:]] = v
+        return template_vars
+
+
 # Import defaults for reference
 from .config_defaults import CONFIG_DEFAULTS
 

janito/agent/conversation.py

@@ -19,6 +19,9 @@ class ConversationHandler:
         self.usage_history = []
 
     def handle_conversation(self, messages, max_rounds=50, on_content=None, on_tool_progress=None, verbose_response=False, spinner=False, max_tokens=None):
+        from janito.agent.runtime_config import runtime_config
+        max_tools = runtime_config.get('max_tools', None)
+        tool_calls_made = 0
         if not messages:
             raise ValueError("No prompt provided in messages")
 
@@ -105,10 +108,15 @@ class ConversationHandler:
                     "usage_history": self.usage_history
                 }
 
+            from janito.agent.runtime_config import runtime_config
             tool_responses = []
+            # Sequential tool execution (default, only mode)
             for tool_call in choice.message.tool_calls:
+                if max_tools is not None and tool_calls_made >= max_tools:
+                    raise MaxRoundsExceededError(f"Maximum number of tool calls ({max_tools}) reached in this chat session.")
                 result = self.tool_handler.handle_tool_call(tool_call, on_progress=on_tool_progress)
                 tool_responses.append({"tool_call_id": tool_call.id, "content": result})
+                tool_calls_made += 1
 
             # Store usage info in usage_history, linked to the next assistant message index
             assistant_idx = len([m for m in messages if m.get('role') == 'assistant'])

janito/agent/runtime_config.py

@@ -16,6 +16,7 @@ class UnifiedConfig:
         self.runtime_cfg = runtime_cfg
         self.effective_cfg = effective_cfg
 
+
     def get(self, key, default=None):
         val = self.runtime_cfg.get(key)
         if val is not None:

janito/agent/tool_handler.py

@@ -8,6 +8,8 @@ class ToolHandler:
     @classmethod
     def register_tool(cls, func):
         import inspect
+        import typing
+        from typing import get_origin, get_args
 
         name = func.__name__
         description = func.__doc__ or ""
@@ -23,18 +25,126 @@ class ToolHandler:
             if param.annotation is param.empty:
                 raise TypeError(f"Parameter '{param_name}' in tool '{name}' is missing a type hint.")
             param_type = param.annotation
-            json_type = "string"
-            if param_type == int:
-                json_type = "integer"
-            elif param_type == float:
-                json_type = "number"
-            elif param_type == bool:
-                json_type = "boolean"
-            elif param_type == dict:
-                json_type = "object"
-            elif param_type == list:
-                json_type = "array"
-            params_schema["properties"][param_name] = {"type": json_type}
+            schema = {}
+
+            # Handle typing.Optional, typing.List, typing.Literal, etc.
+            origin = get_origin(param_type)
+            args = get_args(param_type)
+
+            if origin is typing.Union and type(None) in args:
+                # Optional[...] type
+                main_type = args[0] if args[1] is type(None) else args[1]
+                origin = get_origin(main_type)
+                args = get_args(main_type)
+                param_type = main_type
+            else:
+                main_type = param_type
+
+            if origin is list or origin is typing.List:
+                item_type = args[0] if args else str
+                item_schema = {"type": _pytype_to_json_type(item_type)}
+                schema = {"type": "array", "items": item_schema}
+            elif origin is typing.Literal:
+                schema = {"type": _pytype_to_json_type(type(args[0])), "enum": list(args)}
+            elif main_type == int:
+                schema = {"type": "integer"}
+            elif main_type == float:
+                schema = {"type": "number"}
+            elif main_type == bool:
+                schema = {"type": "boolean"}
+            elif main_type == dict:
+                schema = {"type": "object"}
+            elif main_type == list:
+                schema = {"type": "array", "items": {"type": "string"}}
+            else:
+                schema = {"type": "string"}
+
+            # Optionally add description if available in docstring (not implemented here)
+            params_schema["properties"][param_name] = schema
+            if param.default is param.empty:
+                params_schema["required"].append(param_name)
+
+        cls._tool_registry[name] = {
+            "function": func,
+            "description": description,
+            "parameters": params_schema
+        }
+        return func
+
+def _pytype_to_json_type(pytype):
+    import typing
+    if pytype == int:
+        return "integer"
+    elif pytype == float:
+        return "number"
+    elif pytype == bool:
+        return "boolean"
+    elif pytype == dict:
+        return "object"
+    elif pytype == list or pytype == typing.List:
+        return "array"
+    else:
+        return "string"
+
+class ToolHandler:
+    _tool_registry = {}
+
+    @classmethod
+    def register_tool(cls, func):
+        import inspect
+        import typing
+        from typing import get_origin, get_args
+
+        name = func.__name__
+        description = func.__doc__ or ""
+
+        sig = inspect.signature(func)
+        params_schema = {
+            "type": "object",
+            "properties": {},
+            "required": []
+        }
+
+        for param_name, param in sig.parameters.items():
+            if param.annotation is param.empty:
+                raise TypeError(f"Parameter '{param_name}' in tool '{name}' is missing a type hint.")
+            param_type = param.annotation
+            schema = {}
+
+            # Handle typing.Optional, typing.List, typing.Literal, etc.
+            origin = get_origin(param_type)
+            args = get_args(param_type)
+
+            if origin is typing.Union and type(None) in args:
+                # Optional[...] type
+                main_type = args[0] if args[1] is type(None) else args[1]
+                origin = get_origin(main_type)
+                args = get_args(main_type)
+                param_type = main_type
+            else:
+                main_type = param_type
+
+            if origin is list or origin is typing.List:
+                item_type = args[0] if args else str
+                item_schema = {"type": _pytype_to_json_type(item_type)}
+                schema = {"type": "array", "items": item_schema}
+            elif origin is typing.Literal:
+                schema = {"type": _pytype_to_json_type(type(args[0])), "enum": list(args)}
+            elif main_type == int:
+                schema = {"type": "integer"}
+            elif main_type == float:
+                schema = {"type": "number"}
+            elif main_type == bool:
+                schema = {"type": "boolean"}
+            elif main_type == dict:
+                schema = {"type": "object"}
+            elif main_type == list:
+                schema = {"type": "array", "items": {"type": "string"}}
+            else:
+                schema = {"type": "string"}
+
+            # Optionally add description if available in docstring (not implemented here)
+            params_schema["properties"][param_name] = schema
             if param.default is param.empty:
                 params_schema["required"].append(param_name)
 
@@ -82,46 +192,38 @@ class ToolHandler:
         args = json.loads(tool_call.function.arguments)
         if self.verbose:
             print(f"[Tool Call] {tool_call.function.name} called with arguments: {args}")
+        import inspect
+        sig = inspect.signature(func)
+        if on_progress:
+            on_progress({
+                'event': 'start',
+                'call_id': call_id,
+                'tool': tool_call.function.name,
+                'args': args
+            })
+        if 'on_progress' in sig.parameters and on_progress is not None:
+            args['on_progress'] = on_progress
         try:
-            import inspect
-            sig = inspect.signature(func)
-            if on_progress:
-                on_progress({
-                    'event': 'start',
-                    'call_id': call_id,
-                    'tool': tool_call.function.name,
-                    'args': args
-                })
-            if 'on_progress' in sig.parameters and on_progress is not None:
-                args['on_progress'] = on_progress
             result = func(**args)
-            if self.verbose:
-                preview = result
-                if isinstance(result, str):
-                    lines = result.splitlines()
-                    if len(lines) > 10:
-                        preview = "\n".join(lines[:10]) + "\n... (truncated)"
-                    elif len(result) > 500:
-                        preview = result[:500] + "... (truncated)"
-                print(f"[Tool Result] {tool_call.function.name} returned:\n{preview}")
-            if on_progress:
-                on_progress({
-                    'event': 'finish',
-                    'call_id': call_id,
-                    'tool': tool_call.function.name,
-                    'args': args,
-                    'result': result
-                })
-            return result
         except Exception as e:
-            tb = traceback.format_exc()
-            if on_progress:
-                on_progress({
-                    'event': 'finish',
-                    'call_id': call_id,
-                    'tool': tool_call.function.name,
-                    'args': args,
-                    'error': str(e),
-                    'traceback': tb
-                })
-            return f"Error running tool {tool_call.function.name}: {e}"
+            import traceback
+            error_message = f"[Tool Error] {type(e).__name__}: {e}\n" + traceback.format_exc()
+            result = error_message
+        if self.verbose:
+            preview = result
+            if isinstance(result, str):
+                lines = result.splitlines()
+                if len(lines) > 10:
+                    preview = "\n".join(lines[:10]) + "\n... (truncated)"
+                elif len(result) > 500:
+                    preview = result[:500] + "... (truncated)"
+            print(f"[Tool Result] {tool_call.function.name} returned:\n{preview}")
+        if on_progress:
+            on_progress({
+                'event': 'finish',
+                'call_id': call_id,
+                'tool': tool_call.function.name,
+                'args': args,
+                'result': result
+            })
+        return result

janito/agent/tools/__init__.py

@@ -1,9 +1,12 @@
 from .ask_user import ask_user
-from .file_ops import create_directory, create_file, remove_file, move_file
-from .view_file import view_file
+from .file_ops import create_file, create_directory, remove_file, move_file
+from .get_lines import get_lines
+from .replace_text_in_file import replace_text_in_file
 from .find_files import find_files
-from .search_text import search_text
-from .bash_exec import bash_exec
+from .run_bash_command import run_bash_command
 from .fetch_url import fetch_url
+from .python_exec import python_exec
+from .py_compile import py_compile_file
+from .search_files import search_files
+from .remove_directory import remove_directory
 
-from .file_str_replace import file_str_replace

janito/agent/tools/ask_user.py

@@ -11,7 +11,8 @@ def ask_user(question: str) -> str:
     """
     Ask the user a question and return their response.
 
-    question: The question to ask the user
+    Args:
+        question (str): The question to ask the user.
     """
     from rich import print as rich_print
     from rich.panel import Panel

janito/agent/tools/fetch_url.py

@@ -1,48 +1,40 @@
 import requests
+from typing import Optional, Callable
 from bs4 import BeautifulSoup
 from janito.agent.tool_handler import ToolHandler
 from janito.agent.tools.rich_utils import print_info, print_success, print_error
 
 @ToolHandler.register_tool
-def fetch_url(url: str, search_strings: list[str] = None, on_progress: callable = None) -> str:
+def fetch_url(url: str, search_strings: list[str] = None, on_progress: Optional[Callable[[dict], None]] = None) -> str:
     """
     Fetch the content of a web page and extract its text.
 
-    url: The URL to fetch.
-    search_strings: Optional list of strings to filter the extracted text around those strings.
-    on_progress: Optional callback function for streaming progress updates.
+    Args:
+        url (str): The URL to fetch.
+        search_strings (list[str], optional): List of strings to filter the extracted text around those strings.
+        on_progress (callable, optional): Callback function for streaming progress updates.
     """
-    if on_progress:
-        on_progress({'event': 'start', 'url': url})
     print_info(f"\U0001F310 Fetching URL: {url} ... ")
-    try:
-        response = requests.get(url, timeout=10)
-        response.raise_for_status()
-        if on_progress:
-            on_progress({'event': 'fetched', 'status_code': response.status_code})
-        soup = BeautifulSoup(response.text, 'html.parser')
-        text = soup.get_text(separator=' ', strip=True)
+    response = requests.get(url, timeout=10)
+    response.raise_for_status()
+    if on_progress:
+        on_progress({'event': 'fetched', 'status_code': response.status_code})
+    soup = BeautifulSoup(response.text, 'html.parser')
+    text = soup.get_text(separator='\n')
 
-        if search_strings:
-            filtered = []
-            for s in search_strings:
-                idx = text.find(s)
-                if idx != -1:
-                    start = max(0, idx - 200)
-                    end = min(len(text), idx + len(s) + 200)
-                    snippet = text[start:end]
-                    filtered.append(snippet)
-            if filtered:
-                text = '\n...\n'.join(filtered)
-            else:
-                text = "No matches found for the provided search strings."
+    if search_strings:
+        filtered = []
+        for s in search_strings:
+            idx = text.find(s)
+            if idx != -1:
+                start = max(0, idx - 200)
+                end = min(len(text), idx + len(s) + 200)
+                snippet = text[start:end]
+                filtered.append(snippet)
+        if filtered:
+            text = '\n...\n'.join(filtered)
+        else:
+            text = "No matches found for the provided search strings."
 
-        print_success("\u2705 Success")
-        if on_progress:
-            on_progress({'event': 'done'})
-        return text
-    except Exception as e:
-        print_error(f"\u274c Error: {e}")
-        if on_progress:
-            on_progress({'event': 'error', 'error': str(e)})
-        return f"\u274c Failed to fetch URL '{url}': {e}"
+    print_success("\u2705 Success")
+    return text