janito 1.8.0__py3-none-any.whl → 1.9.0__py3-none-any.whl

janito/__init__.py

@@ -1 +1 @@
-__version__ = "1.8.0"
+__version__ = "1.9.0"

janito/agent/config_defaults.py

@@ -10,4 +10,27 @@ CONFIG_DEFAULTS = {
     "use_azure_openai": False,
     "azure_openai_api_version": "2023-05-15",
     "profile": "base",
+    "providers": {
+        "openai": {
+            "api_key": None,
+            "base_url": "https://api.openai.com/v1",
+            "default_model": "gpt-3.5-turbo",
+        },
+        "azureai": {
+            "api_key": None,
+            "base_url": "https://your-azure-endpoint.openai.azure.com/",
+            "api_version": "2023-05-15",
+            "default_model": "gpt-35-turbo",
+        },
+        "openrouterai": {
+            "api_key": None,
+            "base_url": "https://openrouter.ai/api/v1",
+            "default_model": "openrouter/cognitive",
+        },
+        "fireworksai": {
+            "api_key": None,
+            "base_url": "https://api.fireworks.ai/inference/v1",
+            "default_model": "accounts/fireworks/models/firefunction-v1",
+        },
+    },
 }

janito/agent/config_utils.py

@@ -1,9 +0,0 @@
-def merge_configs(*configs):
-    """
-    Merge multiple config-like objects (with .all()) into one dict.
-    Later configs override earlier ones.
-    """
-    merged = {}
-    for cfg in configs:
-        merged.update(cfg.all())
-    return merged

janito/agent/conversation.py

@@ -30,7 +30,7 @@ class ConversationHandler:
     def handle_conversation(
         self,
         messages,
-        max_rounds=50,
+        max_rounds=100,
         message_handler=None,
         verbose_response=False,
         spinner=False,
@@ -39,7 +39,15 @@ class ConversationHandler:
         stream=False,
         verbose_stream=False,
     ):
-        if not messages:
+        from janito.agent.conversation_history import ConversationHistory
+
+        # Accept either ConversationHistory or a list for backward compatibility
+        if isinstance(messages, ConversationHistory):
+            history = messages
+        else:
+            history = ConversationHistory(messages)
+
+        if len(history) == 0:
             raise ValueError("No prompt provided in messages")
 
         resolved_max_tokens = max_tokens
@@ -66,7 +74,7 @@ class ConversationHandler:
                         return get_openai_stream_response(
                             self.client,
                             self.model,
-                            messages,
+                            history.get_messages(),
                             resolved_max_tokens,
                             verbose_stream=runtime_config.get("verbose_stream", False),
                             message_handler=message_handler,
@@ -78,7 +86,10 @@ class ConversationHandler:
                     # Non-streaming mode
                     def api_call():
                         return get_openai_response(
-                            self.client, self.model, messages, resolved_max_tokens
+                            self.client,
+                            self.model,
+                            history.get_messages(),
+                            resolved_max_tokens,
                         )
 
                     if spinner:
@@ -87,7 +98,6 @@ class ConversationHandler:
                         )
                     else:
                         response = retry_api_call(api_call)
-                        print("[DEBUG] OpenAI API raw response:", repr(response))
             except NoToolSupportError:
                 print(
                     "⚠️ Endpoint does not support tool use. Proceeding in vanilla mode (tools disabled)."
@@ -142,10 +152,19 @@ class ConversationHandler:
             if message_handler is not None and choice.message.content:
                 message_handler.handle_message(event)
             if not choice.message.tool_calls:
-                agent_idx = len([m for m in messages if m.get("role") == "agent"])
+                agent_idx = len(
+                    [m for m in history.get_messages() if m.get("role") == "agent"]
+                )
                 self.usage_history.append(
                     {"agent_index": agent_idx, "usage": usage_info}
                 )
+                # Add assistant response to history
+                history.add_message(
+                    {
+                        "role": "assistant",
+                        "content": choice.message.content,
+                    }
+                )
                 return {
                     "content": choice.message.content,
                     "usage": usage_info,
@@ -155,9 +174,12 @@ class ConversationHandler:
             tool_responses = handle_tool_calls(
                 choice.message.tool_calls, message_handler=message_handler
             )
-            agent_idx = len([m for m in messages if m.get("role") == "agent"])
+            agent_idx = len(
+                [m for m in history.get_messages() if m.get("role") == "agent"]
+            )
             self.usage_history.append({"agent_index": agent_idx, "usage": usage_info})
-            messages.append(
+            # Add assistant response with tool calls
+            history.add_message(
                 {
                     "role": "assistant",
                     "content": choice.message.content,
@@ -165,7 +187,7 @@ class ConversationHandler:
                 }
             )
             for tool_response in tool_responses:
-                messages.append(
+                history.add_message(
                     {
                         "role": "tool",
                         "tool_call_id": tool_response["tool_call_id"],

janito/agent/conversation_api.py

@@ -10,18 +10,36 @@ from janito.agent.tool_registry import get_tool_schemas
 from janito.agent.conversation_exceptions import NoToolSupportError
 
 
+def _sanitize_utf8_surrogates(obj):
+    """
+    Recursively sanitize a dict/list/string by replacing surrogate codepoints with the unicode replacement character.
+    """
+    if isinstance(obj, str):
+        # Encode with surrogatepass, then decode with 'utf-8', replacing errors
+        return obj.encode("utf-8", "replace").decode("utf-8", "replace")
+    elif isinstance(obj, dict):
+        return {k: _sanitize_utf8_surrogates(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [_sanitize_utf8_surrogates(x) for x in obj]
+    else:
+        return obj
+
+
 def get_openai_response(
     client, model, messages, max_tokens, tools=None, tool_choice=None, temperature=None
 ):
     """Non-streaming OpenAI API call."""
+    messages = _sanitize_utf8_surrogates(messages)
+    from janito.agent.conversation_exceptions import ProviderError
+
     if runtime_config.get("vanilla_mode", False):
-        return client.chat.completions.create(
+        response = client.chat.completions.create(
             model=model,
             messages=messages,
             max_tokens=max_tokens,
         )
     else:
-        return client.chat.completions.create(
+        response = client.chat.completions.create(
             model=model,
             messages=messages,
             tools=tools or get_tool_schemas(),
@@ -29,6 +47,17 @@ def get_openai_response(
             temperature=temperature if temperature is not None else 0.2,
             max_tokens=max_tokens,
         )
+    # Explicitly check for missing or empty choices (API/LLM error)
+    if (
+        not hasattr(response, "choices")
+        or response.choices is None
+        or len(response.choices) == 0
+    ):
+        raise ProviderError(
+            "No choices in response; possible API or LLM error.",
+            {"code": 502, "raw_response": str(response)},
+        )
+    return response
 
 
 def get_openai_stream_response(
@@ -43,6 +72,7 @@ def get_openai_stream_response(
     message_handler=None,
 ):
     """Streaming OpenAI API call."""
+    messages = _sanitize_utf8_surrogates(messages)
     openai_args = dict(
         model=model,
         messages=messages,

janito/agent/conversation_history.py

@@ -0,0 +1,53 @@
+from typing import List, Dict, Optional
+import json
+
+
+class ConversationHistory:
+    """
+    Manages the message history for a conversation, supporting OpenAI-style roles.
+    Intended to be used by ConversationHandler and chat loop for all history operations.
+    """
+
+    def __init__(self, messages: Optional[List[Dict]] = None):
+        self._messages = messages.copy() if messages else []
+
+    def add_message(self, message: Dict):
+        """Append a message dict to the history."""
+        self._messages.append(message)
+
+    def get_messages(self, role: Optional[str] = None) -> List[Dict]:
+        """
+        Return all messages, or only those matching a given role/type (e.g., 'assistant', 'user', 'tool').
+        If role is None, returns all messages.
+        """
+        if role is None:
+            return self._messages.copy()
+        return [msg for msg in self._messages if msg.get("role") == role]
+
+    def clear(self):
+        """Remove all messages from history."""
+        self._messages.clear()
+
+    def set_system_message(self, content: str):
+        """
+        Replace the first system prompt message, or insert if not present.
+        """
+        system_idx = next(
+            (i for i, m in enumerate(self._messages) if m.get("role") == "system"), None
+        )
+        system_msg = {"role": "system", "content": content}
+        if system_idx is not None:
+            self._messages[system_idx] = system_msg
+        else:
+            self._messages.insert(0, system_msg)
+
+    def to_json_file(self, path: str):
+        """Save the conversation history as a JSON file to the given path."""
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(self.get_messages(), f, indent=2, ensure_ascii=False)
+
+    def __len__(self):
+        return len(self._messages)
+
+    def __getitem__(self, idx):
+        return self._messages[idx]

janito/agent/conversation_tool_calls.py

@@ -2,6 +2,7 @@
 Helpers for handling tool calls in conversation.
 """
 
+import json
 from janito.agent.tool_executor import ToolExecutor
 from janito.agent import tool_registry
 from .conversation_exceptions import MaxRoundsExceededError
@@ -19,18 +20,20 @@ def handle_tool_calls(tool_calls, message_handler=None):
             )
         tool_entry = tool_registry._tool_registry[tool_call.function.name]
         try:
-            result = ToolExecutor(message_handler=message_handler).execute(
-                tool_entry, tool_call
-            )
-            tool_responses.append({"tool_call_id": tool_call.id, "content": result})
-        except TypeError as e:
-            # Return the error as a tool result, asking to retry with correct params
-            error_msg = str(e)
+            arguments = json.loads(tool_call.function.arguments)
+        except (TypeError, AttributeError, json.JSONDecodeError) as e:
+            error_msg = f"Invalid/malformed function parameters: {e}. Please retry with valid JSON arguments."
             tool_responses.append(
                 {
                     "tool_call_id": tool_call.id,
-                    "content": f"Tool execution error: {error_msg}. Please retry with the correct parameters.",
+                    "content": error_msg,
                 }
             )
+            tool_calls_made += 1
+            continue
+        result = ToolExecutor(message_handler=message_handler).execute(
+            tool_entry, tool_call, arguments
+        )
+        tool_responses.append({"tool_call_id": tool_call.id, "content": result})
         tool_calls_made += 1
     return tool_responses

janito/agent/openai_client.py

@@ -64,18 +64,18 @@ class Agent:
 
     def chat(
         self,
-        messages,
+        messages=None,
         message_handler=None,
         spinner=False,
         max_tokens=None,
-        max_rounds=50,
+        max_rounds=100,
         stream=False,
     ):
         """
         Start a chat conversation with the agent.
 
         Args:
-            messages: List of message dicts.
+            messages: ConversationHistory instance or None.
             message_handler: Optional handler for streaming or event messages.
             spinner: Show spinner during request.
             max_tokens: Max tokens for completion.
@@ -86,6 +86,14 @@ class Agent:
             If stream=True: generator yielding content chunks or events.
         """
         from janito.agent.runtime_config import runtime_config
+        from janito.agent.conversation_history import ConversationHistory
+
+        if messages is None:
+            messages = ConversationHistory()
+        elif not isinstance(messages, ConversationHistory):
+            raise TypeError(
+                "Agent.chat expects a ConversationHistory instance or None."
+            )
 
         max_retries = 5
         for attempt in range(1, max_retries + 1):

janito/agent/openai_schema_generator.py

@@ -124,12 +124,15 @@ def generate_openai_function_schema(func, tool_name: str, tool_class=None):
         )
     properties = OrderedDict()
     required = []
-    # Inject tool_call_reason as the first required parameter
-    properties["tool_call_reason"] = {
-        "type": "string",
-        "description": "The reason or context for why this tool is being called. This is required for traceability.",
-    }
-    required.append("tool_call_reason")
+    # Inject tool_call_reason as the first required parameter, unless --ntt is set
+    from janito.agent.runtime_config import runtime_config
+
+    if not runtime_config.get("no_tools_tracking", False):
+        properties["tool_call_reason"] = {
+            "type": "string",
+            "description": "The reason or context for why this tool is being called. This is required for traceability.",
+        }
+        required.append("tool_call_reason")
     for name, param in sig.parameters.items():
         if name == "self":
             continue

janito/agent/providers.py

@@ -0,0 +1,77 @@
+"""Providers module: defines LLM provider interfaces and implementations."""
+
+from abc import ABC, abstractmethod
+
+
+class Provider(ABC):
+    """Abstract base class for LLM providers."""
+
+    def __init__(self, config: dict):
+        self.config = config
+
+    @abstractmethod
+    def create_client(self):
+        """Instantiate and return the provider-specific client."""
+        pass
+
+    @abstractmethod
+    def get_default_model(self) -> str:
+        """Return the default model for this provider."""
+        pass
+
+
+class OpenAIProvider(Provider):
+    def create_client(self):
+        from openai import OpenAI
+
+        return OpenAI(
+            base_url=self.config.get("base_url", "https://api.openai.com/v1"),
+            api_key=self.config["api_key"],
+        )
+
+    def get_default_model(self) -> str:
+        return self.config.get("default_model", "gpt-3.5-turbo")
+
+
+class AzureAIProvider(Provider):
+    def create_client(self):
+        from openai import AzureOpenAI
+
+        return AzureOpenAI(
+            api_key=self.config["api_key"],
+            azure_endpoint=self.config["base_url"],
+            api_version=self.config.get("api_version", "2023-05-15"),
+        )
+
+    def get_default_model(self) -> str:
+        return self.config.get("default_model", "gpt-35-turbo")
+
+
+class OpenrouterAIProvider(Provider):
+    def create_client(self):
+        from openai import OpenAI
+
+        return OpenAI(
+            base_url=self.config.get("base_url", "https://openrouter.ai/api/v1"),
+            api_key=self.config["api_key"],
+        )
+
+    def get_default_model(self) -> str:
+        return self.config.get("default_model", "openrouter/cognitive")
+
+
+class FireworksAIProvider(Provider):
+    def create_client(self):
+        from openai import OpenAI
+
+        return OpenAI(
+            base_url=self.config.get(
+                "base_url", "https://api.fireworks.ai/inference/v1"
+            ),
+            api_key=self.config["api_key"],
+        )
+
+    def get_default_model(self) -> str:
+        return self.config.get(
+            "default_model", "accounts/fireworks/models/firefunction-v1"
+        )

janito/agent/rich_message_handler.py

@@ -38,7 +38,7 @@ class RichMessageHandler(MessageHandlerProtocol):
         if msg_type == "content":
             self.console.print(Markdown(message))
         elif msg_type == "info":
-            self.console.print(message, style="cyan", end="")
+            self.console.print(f"  {message}", style="cyan", end="")
         elif msg_type == "success":
             self.console.print(message, style="bold green", end="\n")
         elif msg_type == "error":

janito/agent/templates/profiles/system_prompt_template_base.txt.j2

@@ -1,14 +1,14 @@
-You are acting as: {{ role }}
+You are: {{ role }}
 
-You have access for development purposes to the following environment:
+You will be developing and testing in the following environment:
  Platform: {{ platform }}
  Python version: {{ python_version }}
  Shell/Environment: {{ shell_info }}
 
-Answer according to the following guidelines:
-  - Start by searching for text/files in the project.
+Respond according to the following guidelines:
+  - Before answering check for files in the current project that might be related to the question
   - Before using your namespace functions, provide a concise explanation.
-  - Prefer making localized edits using string replacements. If the required change is extensive, replace the entire file instead.
-  - When locating code lines to change, consider the previous lines content for indentation precise replacement.
-  - After edting files, validate them.
-
+  - When you are likely to need the entire file content, get the full content by omitting range numbers
+  - Do not provide the code in the messages, use the namespace functions to provide the cocde changes.
+  - Prefer making localized edits using string replacements. If the required change is extensive, replace the entire file instead, provide full content without placeholders.
+  - When locating code lines to change, check the surrounding lines content for indentation precise replacement.

janito/agent/tool_executor.py

@@ -3,7 +3,6 @@
 ToolExecutor: Responsible for executing tools, validating arguments, handling errors, and reporting progress.
 """
 
-import json
 from janito.i18n import tr
 import inspect
 from janito.agent.tool_base import ToolBase
@@ -14,15 +13,18 @@ class ToolExecutor:
     def __init__(self, message_handler=None):
         self.message_handler = message_handler
 
-    def execute(self, tool_entry, tool_call):
+    def execute(self, tool_entry, tool_call, arguments):
         import uuid
 
         call_id = getattr(tool_call, "id", None) or str(uuid.uuid4())
         func = tool_entry["function"]
-        args = json.loads(tool_call.function.arguments)
-        tool_call_reason = args.pop(
-            "tool_call_reason", None
-        )  # Extract and remove 'tool_call_reason' if present
+        args = arguments
+        if runtime_config.get("no_tools_tracking", False):
+            tool_call_reason = None
+        else:
+            tool_call_reason = args.pop(
+                "tool_call_reason", None
+            )  # Extract and remove 'tool_call_reason' if present
         # Record tool usage
         try:
             from janito.agent.tool_use_tracker import ToolUseTracker
@@ -61,7 +63,7 @@ class ToolExecutor:
                 "call_id": call_id,
                 "arguments": args,
             }
-            if tool_call_reason:
+            if tool_call_reason and not runtime_config.get("no_tools_tracking", False):
                 event["tool_call_reason"] = tool_call_reason
             self.message_handler.handle_message(event)
         # Argument validation
@@ -77,7 +79,9 @@ class ToolExecutor:
                     "call_id": call_id,
                     "error": error_msg,
                 }
-                if tool_call_reason:
+                if tool_call_reason and not runtime_config.get(
+                    "no_tools_tracking", False
+                ):
                     error_event["tool_call_reason"] = tool_call_reason
                 self.message_handler.handle_message(error_event)
             raise TypeError(error_msg)
@@ -91,7 +95,9 @@ class ToolExecutor:
                     "call_id": call_id,
                     "result": result,
                 }
-                if tool_call_reason:
+                if tool_call_reason and not runtime_config.get(
+                    "no_tools_tracking", False
+                ):
                     result_event["tool_call_reason"] = tool_call_reason
                 self.message_handler.handle_message(result_event)
             return result
@@ -103,7 +109,9 @@ class ToolExecutor:
                     "call_id": call_id,
                     "error": str(e),
                 }
-                if tool_call_reason:
+                if tool_call_reason and not runtime_config.get(
+                    "no_tools_tracking", False
+                ):
                     error_event["tool_call_reason"] = tool_call_reason
                 self.message_handler.handle_message(error_event)
             raise

janito/agent/tool_use_tracker.py

@@ -41,6 +41,22 @@ class ToolUseTracker:
                         return True
         return False
 
+    def last_operation_is_full_read_or_replace(self, file_path: str) -> bool:
+        ops = self.get_operations_on_file(file_path)
+        if not ops:
+            return False
+        last = ops[-1]
+        if last["tool"] == "replace_file":
+            return True
+        if last["tool"] == "get_lines":
+            params = last["params"]
+            if params.get("from_line") is None and params.get("to_line") is None:
+                return True
+        return False
+
+    def clear_history(self):
+        self._history.clear()
+
     @classmethod
     def instance(cls):
         return cls()

janito/agent/tools/__init__.py

@@ -1,17 +1,17 @@
 from . import ask_user
 from . import create_directory
 from . import create_file
+from . import replace_file
 from . import fetch_url
 from . import find_files
 from . import get_lines
-from . import outline_file
-from . import gitignore_utils
+from .get_file_outline import core  # noqa: F401,F811
 from . import move_file
-from . import validate_file_syntax
+from .validate_file_syntax import core  # noqa: F401,F811
 from . import remove_directory
 from . import remove_file
 from . import replace_text_in_file
-from . import rich_live
+from . import delete_text_in_file
 from . import run_bash_command
 from . import run_powershell_command
 from . import run_python_command
@@ -24,21 +24,19 @@ __all__ = [
     "create_file",
     "fetch_url",
     "find_files",
-    "outline_file",
+    "GetFileOutlineTool",
     "get_lines",
-    "gitignore_utils",
     "move_file",
     "validate_file_syntax",
     "remove_directory",
     "remove_file",
+    "replace_file",
     "replace_text_in_file",
-    "rich_live",
+    "delete_text_in_file",
     "run_bash_command",
     "run_powershell_command",
     "run_python_command",
     "search_files",
-    "tools_utils",
-    "memory",
     "present_choices",
     "search_text",
 ]

janito/agent/tools/create_directory.py

@@ -1,5 +1,7 @@
 from janito.agent.tool_registry import register_tool
-from janito.agent.tools.utils import expand_path, display_path
+
+# from janito.agent.tools_utils.expand_path import expand_path
+from janito.agent.tools_utils.utils import display_path
 from janito.agent.tool_base import ToolBase
 from janito.i18n import tr
 import os
@@ -18,10 +20,11 @@ class CreateDirectoryTool(ToolBase):
     """
 
     def run(self, file_path: str) -> str:
-        file_path = expand_path(file_path)
+        # file_path = expand_path(file_path)
+        # Using file_path as is
         disp_path = display_path(file_path)
         self.report_info(
-            tr("📁 Creating directory: '{disp_path}' ...", disp_path=disp_path)
+            tr("📁 Creating directory '{disp_path}' ...", disp_path=disp_path)
         )
         try:
             if os.path.exists(file_path):
@@ -47,9 +50,7 @@ class CreateDirectoryTool(ToolBase):
                     disp_path=disp_path,
                 )
             os.makedirs(file_path, exist_ok=True)
-            self.report_success(
-                tr("✅ Directory created at '{disp_path}'", disp_path=disp_path)
-            )
+            self.report_success(tr("✅ Directory created"))
             return tr(
                 "✅ Successfully created the directory at '{disp_path}'.",
                 disp_path=disp_path,