janito 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

janito/cli/runner.py

@@ -1,14 +1,11 @@
 import sys
-import os
 from rich.console import Console
-from rich.markdown import Markdown
 from janito.render_prompt import render_system_prompt
 from janito.agent.agent import Agent
 from janito.agent.conversation import MaxRoundsExceededError, EmptyResponseError, ProviderError
 from janito.agent.runtime_config import unified_config, runtime_config
 from janito.agent.config import get_api_key
 from janito import __version__
-from rich.rule import Rule
 
 
 def format_tokens(n):
@@ -56,8 +53,8 @@ def run_cli(args):
         runtime_config.set('system_prompt_file', args.system_file)
 
     else:
-        system_prompt = args.system_prompt or unified_config.get("system_prompt")
-        if args.system_prompt:
+        system_prompt = args.system or unified_config.get("system_prompt")
+        if args.system:
             runtime_config.set('system_prompt', system_prompt)
         if system_prompt is None:
             # Pass full merged config (runtime overrides effective)
@@ -81,11 +78,18 @@ def run_cli(args):
     model = unified_config.get('model')
     base_url = unified_config.get('base_url', 'https://openrouter.ai/api/v1')
     azure_openai_api_version = unified_config.get('azure_openai_api_version', '2023-05-15')
-    # Handle --enable-tools flag
-    from janito.agent.tool_handler import ToolHandler
-    tool_handler = ToolHandler(verbose=args.verbose_tools, enable_tools=not getattr(args, 'no_tools', False))
-    use_azure_openai = unified_config.get('use_azure_openai', False)
-    agent = Agent(api_key=api_key, model=model, system_prompt=system_prompt, verbose_tools=args.verbose_tools, base_url=base_url, tool_handler=tool_handler, azure_openai_api_version=azure_openai_api_version, use_azure_openai=use_azure_openai)
+    # Handle vanilla mode
+    vanilla_mode = getattr(args, 'vanilla', False)
+    if vanilla_mode:
+        runtime_config.set('vanilla_mode', True)
+        system_prompt = None
+        runtime_config.set('system_prompt', None)
+        # Only set temperature if explicitly provided
+        if args.temperature is None:
+            runtime_config.set('temperature', None)
+    else:
+        runtime_config.set('vanilla_mode', False)
+    agent = Agent(api_key=api_key, model=model, system_prompt=system_prompt, verbose_tools=args.verbose_tools, base_url=base_url, azure_openai_api_version=azure_openai_api_version, use_azure_openai=unified_config.get('use_azure_openai', False))
 
     # Save runtime max_tokens override if provided
     if args.max_tokens is not None:
@@ -100,10 +104,10 @@ def run_cli(args):
     prompt = args.prompt
 
     console = Console()
+    from janito.agent.rich_tool_handler import MessageHandler
+    message_handler = MessageHandler()
 
-    def on_content(data):
-        content = data.get("content", "")
-        console.print(Markdown(content))
+    # Removed on_content logic; use message_handler pattern only
 
     messages = []
     if agent.system_prompt:
@@ -116,7 +120,7 @@ def run_cli(args):
             max_rounds = runtime_config.get('max_rounds', 50)
             response = agent.chat(
                 messages,
-                on_content=on_content,
+                message_handler=message_handler,
                 spinner=True,
                 max_rounds=max_rounds,
             )

janito/cli_chat_shell/chat_loop.py

@@ -1,5 +1,4 @@
-from rich.console import Console
-from rich.markdown import Markdown
+from janito.agent.rich_tool_handler import MessageHandler
 from prompt_toolkit.history import InMemoryHistory
 from .session_manager import load_last_conversation, load_input_history
 from .ui import print_welcome, get_toolbar_func, get_prompt_session
@@ -11,7 +10,8 @@ from janito.agent.conversation import EmptyResponseError, ProviderError
 
 
 def start_chat_shell(agent, continue_session=False, max_rounds=50):
-    console = Console()
+    message_handler = MessageHandler()
+    console = message_handler.console
 
     # Load input history
     history_list = load_input_history()
@@ -45,7 +45,7 @@ def start_chat_shell(agent, continue_session=False, max_rounds=50):
         state['messages'] = messages
         state['last_usage_info'] = last_usage_info
         state['mem_history'] = mem_history
-        console.print('[bold green]Restored last saved conversation.[/bold green]')
+        message_handler.handle_message({'type': 'success', 'message': 'Restored last saved conversation.'})
 
     # Add system prompt if needed
     if agent.system_prompt and not any(m.get('role') == 'system' for m in messages):
@@ -97,10 +97,10 @@ def start_chat_shell(agent, continue_session=False, max_rounds=50):
             try:
                 confirm = input("Do you really want to exit? (y/n): ").strip().lower()
             except KeyboardInterrupt:
-                console.print("\n[bold red]Exiting...[/bold red]")
+                message_handler.handle_message({'type': 'error', 'message': 'Exiting...'})
                 break
             if confirm == 'y':
-                console.print("[bold red]Exiting...[/bold red]")
+                message_handler.handle_message({'type': 'error', 'message': 'Exiting...'})
                 break
             else:
                 continue
@@ -121,22 +121,17 @@ def start_chat_shell(agent, continue_session=False, max_rounds=50):
         import time
         start_time = time.time()
 
-        # Define streaming content handler
-        def on_content(chunk):
-            content_piece = chunk.get('content')
-            if content_piece:
-                console.print(Markdown(content_piece))
 
         try:
-            response = agent.chat(messages, on_content=on_content, spinner=True, max_rounds=max_rounds)
+            response = agent.chat(messages, spinner=True, max_rounds=max_rounds, message_handler=message_handler)
         except KeyboardInterrupt:
-            console.print("[bold yellow]Request interrupted. Returning to prompt.[/bold yellow]")
+            message_handler.handle_message({'type': 'info', 'message': 'Request interrupted. Returning to prompt.'})
             continue
         except ProviderError as e:
-            console.print(f"[bold red]Provider error:[/bold red] {e}")
+            message_handler.handle_message({'type': 'error', 'message': f'Provider error: {e}'})
             continue
         except EmptyResponseError as e:
-            console.print(f"[bold red]Error:[/bold red] {e}")
+            message_handler.handle_message({'type': 'error', 'message': f'Error: {e}'})
             continue
         last_elapsed = time.time() - start_time
 

janito/cli_chat_shell/commands.py

@@ -4,7 +4,6 @@ import json
 from prompt_toolkit.history import InMemoryHistory
 from janito.render_prompt import render_system_prompt
 from .load_prompt import load_prompt
-from janito.agent.config import effective_config
 
 
 def handle_exit(console, **kwargs):
@@ -171,6 +170,7 @@ def handle_role(console, *args, **kwargs):
     console.print(f"[bold green]System role updated to:[/bold green] {new_role}")
 
 
+
 COMMAND_HANDLERS = {
     "/history": handle_history,
     "/continue": handle_continue,
@@ -180,12 +180,17 @@ COMMAND_HANDLERS = {
     "/help": handle_help,
     "/multi": handle_multi,
     "/system": handle_system,
-    "/role": handle_role,
+}
+
+if not runtime_config.get('vanilla_mode', False):
+    COMMAND_HANDLERS["/role"] = handle_role
+
+COMMAND_HANDLERS.update({
     "/clear": handle_clear,
     "/reset": handle_reset,
     "/config": handle_config_shell,
     "/reload": handle_reload,
-}
+})
 
 
 def handle_command(command, console, **kwargs):

janito/cli_chat_shell/config_shell.py

@@ -1,9 +1,6 @@
 from janito.agent.config import local_config, global_config, CONFIG_OPTIONS
 from janito.agent.config_defaults import CONFIG_DEFAULTS
 from janito.agent.runtime_config import unified_config, runtime_config
-from janito.cli._print_config import print_config_items
-from rich import print
-import sys
 
 def handle_config_shell(console, *args, **kwargs):
     """

janito/cli_chat_shell/session_manager.py

@@ -54,3 +54,14 @@ def save_input_history(history_list):
     history_file = os.path.join(history_dir, f'{today_str}.json')
     with open(history_file, 'w', encoding='utf-8') as f:
         json.dump(history_list, f, indent=2)
+
+def last_conversation_exists(path='.janito/last_conversation.json'):
+    if not os.path.exists(path):
+        return False
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        messages = data.get('messages', [])
+        return bool(messages)
+    except Exception:
+        return False

janito/cli_chat_shell/ui.py

@@ -1,11 +1,9 @@
-from rich.console import Console
-from rich.markdown import Markdown
 from prompt_toolkit import PromptSession
-from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.enums import EditingMode
 from prompt_toolkit.formatted_text import HTML
 from prompt_toolkit.styles import Style
-from prompt_toolkit.history import InMemoryHistory
+from janito.agent.runtime_config import runtime_config
+from .session_manager import last_conversation_exists
 
 
 def print_summary(console, data, continue_session):
@@ -26,120 +24,21 @@ def print_summary(console, data, continue_session):
         ctok = usage.get('completion_tokens')
         tot = (ptok or 0) + (ctok or 0)
         console.print(f"Tokens - Prompt: {ptok}, Completion: {ctok}, Total: {tot}")
-    if not continue_session:
+    # Only print /continue suggestion if a last conversation exists
+    if not continue_session and last_conversation_exists():
         console.print("[bold yellow]Type /continue to restore the last saved conversation.[/bold yellow]")
 
 
 def print_welcome(console, version=None, continued=False):
     version_str = f" (v{version})" if version else ""
-    console.print(f"[bold green]Welcome to Janito{version_str}! Entering chat mode. Type /exit to exit.[/bold green]")
-    if not continued:
+    vanilla_mode = runtime_config.get('vanilla_mode', False)
+    if vanilla_mode:
+        console.print(f"[bold magenta]Welcome to Janito{version_str} in [white on magenta]VANILLA MODE[/white on magenta]! Tools, system prompt, and temperature are disabled unless overridden.[/bold magenta]")
+    else:
+        console.print(f"[bold green]Welcome to Janito{version_str}! Entering chat mode. Type /exit to exit.[/bold green]")
+    # Only print /continue suggestion if a last conversation exists
+    if not continued and last_conversation_exists():
         console.print("[yellow]To resume your previous conversation, type /continue at any time.[/yellow]")
 
 
-def get_toolbar_func(messages_ref, last_usage_info_ref, last_elapsed_ref, model_name=None, role_ref=None):
-    def format_tokens(n):
-        if n is None:
-            return "?"
-        if n >= 1_000_000:
-            return f"{n/1_000_000:.1f}m"
-        if n >= 1_000:
-            return f"{n/1_000:.1f}k"
-        return str(n)
-
-    def get_toolbar():
-        left = f' Messages:  <msg_count>{len(messages_ref())}</msg_count>'
-        usage = last_usage_info_ref()
-        last_elapsed = last_elapsed_ref()
-        if usage:
-            prompt_tokens = usage.get('prompt_tokens')
-            completion_tokens = usage.get('completion_tokens')
-            total_tokens = (prompt_tokens or 0) + (completion_tokens or 0)
-            speed = None
-            if last_elapsed and last_elapsed > 0:
-                speed = total_tokens / last_elapsed
-            left += (
-                f" | Tokens: In=<tokens_in>{format_tokens(prompt_tokens)}</tokens_in> / "
-                f"Out=<tokens_out>{format_tokens(completion_tokens)}</tokens_out> / "
-                f"Total=<tokens_total>{format_tokens(total_tokens)}</tokens_total>"
-            )
-            if speed is not None:
-                left += f", speed=<speed>{speed:.1f}</speed> tokens/sec"
-
-        from prompt_toolkit.application import get_app
-
-        # Compose first line with Model and Role
-        width = get_app().output.get_size().columns
-
-
-        model_part = f" Model:  <model>{model_name}</model>" if model_name else ""
-        role_part = ""
-        if role_ref:
-            role = role_ref()
-            if role:
-                role_part = f"Role: <b>{role}</b>"
-
-        first_line_parts = []
-        if model_part:
-            first_line_parts.append(model_part)
-        if role_part:
-            first_line_parts.append(role_part)
-        first_line = " | ".join(first_line_parts)
-
-        help_part = "<b>/help</b> for help | <b>F12</b>: just do it"
-
-        total_len = len(left) + len(help_part) + 3  # separators and spaces
-        if first_line:
-            total_len += len(first_line) + 3
-
-        if total_len < width:
-            padding = ' ' * (width - total_len)
-            second_line = f"{left}{padding} | {help_part}"
-        else:
-            second_line = f"{left} | {help_part}"
-
-        if first_line:
-            toolbar_text = first_line + "\n" + second_line
-        else:
-            toolbar_text = second_line
-
-        return HTML(toolbar_text)
-
-    return get_toolbar
-
-
-def get_prompt_session(get_toolbar_func, mem_history):
-    from prompt_toolkit.key_binding import KeyBindings
-    style = Style.from_dict({
-        'bottom-toolbar': 'bg:#333333 #ffffff',
-        'b': 'bold',
-        'prompt': 'bold bg:#000080 #ffffff',
-        'model': 'bold bg:#005f5f #ffffff',  # distinct background/foreground
-        'msg_count': 'bg:#333333 #ffff00 bold',
-        'tokens_in': 'ansicyan bold',
-        'tokens_out': 'ansigreen bold',
-        'tokens_total': 'ansiyellow bold',
-        'speed': 'ansimagenta bold',
-'right': 'bg:#005f5f #ffffff',
-        'input': 'bg:#000080 #ffffff',
-'': 'bg:#000080 #ffffff',
-    })
-
-    kb = KeyBindings()
-
-    @kb.add('f12')
-    def _(event):
-        """When F12 is pressed, send 'just do it' as input immediately."""
-        buf = event.app.current_buffer
-        buf.text = 'just do it'
-        buf.validate_and_handle()
-
-    session = PromptSession(
-        multiline=False,
-        key_bindings=kb,
-        editing_mode=EditingMode.EMACS,
-        bottom_toolbar=get_toolbar_func,
-        style=style,
-        history=mem_history
-    )
-    return session
+# ... rest of the file remains unchanged ...

janito/render_prompt.py

@@ -1,7 +1,6 @@
 import jinja2
 from pathlib import Path
 
-from janito.agent.runtime_config import unified_config
 
 def render_system_prompt(role: str) -> str:
     template_loader = jinja2.FileSystemLoader(searchpath=str(Path(__file__).parent / "agent" / "templates"))

janito/rich_utils.py

@@ -0,0 +1,30 @@
+"""
+Utilities for working with the Rich library.
+"""
+from rich.markdown import Markdown
+from rich.text import Text
+from rich.console import Console
+
+def print_markdown(console: Console, message: str):
+    console.print(Markdown(message))
+
+def print_info(console: Console, message: str):
+    console.print(message, style="cyan", end="")
+
+def print_success(console: Console, message: str):
+    console.print(message, style="bold green", end="\n")
+
+def print_error(console: Console, message: str):
+    console.print(message, style="bold red", end="\n")
+
+def print_warning(console: Console, message: str):
+    console.print(message, style="bold yellow", end="\n")
+
+def print_magenta(console: Console, message: str):
+    console.print(message, style="magenta", end="\n")
+
+def print_stdout(console: Console, message: str):
+    console.print(Text(message, style="on #003300", no_wrap=True, overflow=None), end="")
+
+def print_stderr(console: Console, message: str):
+    console.print(Text(message, style="on #330000", no_wrap=True, overflow=None), end="")

janito/web/app.py

@@ -1,12 +1,13 @@
-from flask import Flask, request, Response, send_from_directory, session, jsonify
+from flask import Flask, request, Response, send_from_directory, jsonify, render_template
 from queue import Queue
 import json
-from janito.agent.queued_tool_handler import QueuedToolHandler
+from janito.agent.queued_message_handler import QueuedMessageHandler
 from janito.agent.agent import Agent
-from janito.agent.config import get_api_key
 from janito.render_prompt import render_system_prompt
 import os
 import threading
+import traceback
+import sys
 
 from janito.agent.runtime_config import unified_config
 
@@ -37,21 +38,20 @@ conversation = None
 # Global event queue for streaming
 stream_queue = Queue()
 
-# Create a QueuedToolHandler with the queue
-queued_handler = QueuedToolHandler(stream_queue)
+# Create a QueuedMessageHandler with the queue
+message_handler = QueuedMessageHandler(stream_queue)
 
-# Instantiate the Agent with config-driven parameters
+# Instantiate the Agent with config-driven parameters (no tool_handler)
 agent = Agent(
     api_key=unified_config.get("api_key"),
     model=unified_config.get("model"),
-    base_url=unified_config.get("base_url"),
-    tool_handler=queued_handler
+    base_url=unified_config.get("base_url")
 )
 
 @app.route('/get_config')
 def get_config():
     # Expose full config for the web app: defaults, effective, runtime (mask api_key)
-    from janito.agent.runtime_config import unified_config
+    from janito.agent.runtime_config import unified_config  # Kept here: avoids circular import at module level
     from janito.agent.config_defaults import CONFIG_DEFAULTS
     # Start with defaults
     config = dict(CONFIG_DEFAULTS)
@@ -145,7 +145,7 @@ def execute_stream():
         try:
             response = agent.chat(
                 conversation,
-                on_content=lambda data: stream_queue.put({"type": "content", "content": data.get("content")})
+                message_handler=message_handler
             )
             if response and 'content' in response:
                 conversation.append({"role": "assistant", "content": response['content']})
@@ -156,7 +156,6 @@ def execute_stream():
             except Exception as e:
                 print(f"Error saving conversation: {e}")
         except Exception as e:
-            import traceback
             tb = traceback.format_exc()
             stream_queue.put({"type": "error", "error": str(e), "traceback": tb})
         finally:
@@ -174,7 +173,6 @@ def execute_stream():
             else:
                 message = json.dumps(content)
             yield f"data: {message}\n\n"
-            import sys
             sys.stdout.flush()
 
     return Response(

janito-1.5.0.dist-info/METADATA

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: janito
+Version: 1.5.0
+Summary: A Natural Programming Language Agent,
+Author-email: João Pinto <joao.pinto@gmail.com>
+License: MIT
+Project-URL: homepage, https://github.com/joaompinto/janito
+Project-URL: repository, https://github.com/joaompinto/janito
+Keywords: agent,framework,tools,automation
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: beautifulsoup4
+Requires-Dist: docstring-parser
+Requires-Dist: flask
+Requires-Dist: jinja2
+Requires-Dist: openai
+Requires-Dist: pathspec
+Requires-Dist: prompt_toolkit
+Requires-Dist: requests
+Requires-Dist: rich
+Dynamic: license-file
+
+# 🚀 Janito: Natural Programming Language Agent
+
+**Current Version: 1.5.x**  
+See [docs/CHANGELOG.md](docs/CHANGELOG.md) and [RELEASE_NOTES_1.5.md](./RELEASE_NOTES_1.5.md) for details on the latest release.
+
+Janito is an AI-powered assistant for the command line and web that interprets natural language instructions to edit code, manage files, and analyze projects using patterns and tools designed by experienced software engineers. It prioritizes transparency, interactive clarification, and precise, reviewable changes.
+
+For a technical overview, see the [Architecture Guide](docs/ARCHITECTURE.md).
+
+---
+
+## ⚡ Quick Start
+
+## 🖥️ Supported Human Interfaces
+Janito supports multiple ways for users to interact with the agent:
+
+- **CLI (Command Line Interface):** Run single prompts or commands directly from your terminal (e.g., `janito "Refactor the data processing module"`).
+- **CLI Chat Shell:** Start an interactive chat session in your terminal for conversational workflows (`janito`).
+- **Web Interface:** Launch a browser-based UI for chat and project management (`janito --web`).
+
+
+![Janito Terminal Screenshot](https://github.com/joaompinto/janito/blob/main/docs/imgs/terminal.png?raw=true)
+
+### 🛠️ Common CLI Modifiers
+You can alter Janito's behavior in any interface using these flags:
+
+- `--system` / `--system-file`: Override or customize the system prompt for the session.
+- `--no-tools`: Disable all tool usage (Janito will only use the language model, no file/code/shell actions).
+- `--vanilla`: Disables tools, system prompt, and temperature settings for a pure LLM chat experience.
+
+These modifiers can be combined with any interface mode for tailored workflows.
+
+
+Run a one-off prompt:
+```bash
+janito "Refactor the data processing module to improve readability."
+```
+
+Or start the interactive chat shell:
+```bash
+janito
+```
+
+While in the chat shell, you can use special commands like `/reload` to reload the system prompt from a file without restarting your session. See the documentation for more shell commands.
+
+Launch the web UI:
+```bash
+janito --web
+```
+
+---
+
+## ✨ Key Features
+- 📝 **Code Editing via Natural Language:** Modify, create, or delete code files simply by describing the changes.
+- 📁 **File & Directory Management:** Navigate, create, move, or remove files and folders.
+- 🧠 **Context-Aware:** Understands your project structure for precise edits.
+- 💬 **Interactive User Prompts:** Asks for clarification when needed.
+- 🧩 **Extensible Tooling:** Built-in tools for file operations, shell commands, directory and file management, Python code execution and validation, text replacement, and more.
+  - See [janito/agent/tools/README.md](janito/agent/tools/README.md) for the full list of built-in tools and their usage details. For the message handler model, see [docs/MESSAGE_HANDLER_MODEL.md](docs/MESSAGE_HANDLER_MODEL.md).
+- 🌐 **Web Interface (In Development):** Simple web UI for streaming responses and tool progress.
+
+## 📦 Installation
+
+### Requirements
+- Python 3.10+
+
+
+### Contributing & Developer Guide
+
+If you want to extend Janito or add new tools, see the [Developer Guide](docs/README_DEV.md) for instructions, tool registration requirements, and code style guidelines. For the full list of built-in tools and their usage, see the [Tools Reference](janito/agent/tools/README.md).
+
+
+
+For the full changelog, see [docs/CHANGELOG.md](docs/CHANGELOG.md).
+
+...
+
+### Configuration & CLI Options
+
+See [docs/CONFIGURATION.md](docs/CONFIGURATION.md) for all configuration parameters, CLI flags, and advanced usage details. All CLI and configuration options have been moved there for clarity and maintainability.
+
+
+### Obtaining an API Key from OpenRouter
+
+To use Janito with OpenRouter, you need an API key:
+
+1. Visit https://openrouter.ai and sign up for an account.
+2. After logging in, go to your account dashboard.
+3. Navigate to the "API Keys" section.
+4. Click "Create new key" and copy the generated API key.
+5. Set your API key in Janito using:
+   ```bash
+   python -m janito --set-api-key YOUR_OPENROUTER_KEY
+   ```
+   Or add it to your configuration file as `api_key`.
+
+**Keep your API key secure and do not share it publicly.**
+
+### Using Azure OpenAI
+
+For details on using models hosted on Azure OpenAI, see [docs/AZURE_OPENAI.md](docs/AZURE_OPENAI.md).
+
+
+
+---
+
+## 🧩 System Prompt & Role
+
+Janito operates using a system prompt template that defines its behavior, communication style, and capabilities. By default, Janito assumes the role of a "software engineer"—this means its responses and actions are tailored to the expectations and best practices of professional software engineering.
+
+- **Role:** You can customize the agent's role (e.g., "data scientist", "DevOps engineer") using the `--role` flag or config. The default is `software engineer`.
+- **System Prompt Template:** The system prompt is rendered from a Jinja2 template (see `janito/agent/templates/system_instructions.j2`). This template governs how the agent interprets instructions, interacts with files, and communicates with users.
+- **Customization & Precedence:** Advanced users can override the system prompt with the `--system` flag (raw string), or point to a custom file using `--system-file`. The precedence is: `--system-file` > `--system`/config > default template.
+
+The default template ensures the agent:
+- Prioritizes safe, reviewable, and minimal changes
+- Asks for clarification when instructions are ambiguous
+- Provides concise plans before taking action
+- Documents any changes made
+
+For more details or to customize the prompt, see the template file at `janito/agent/templates/system_instructions.j2` and the architecture overview in [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md).
+
+---
+
+
+## 🥛 Vanilla Mode
+
+Janito supports a "vanilla mode" for pure LLM interaction:
+
+- No tools: Disables all tool use (no file operations, shell commands, etc.).
+- No system prompt: The LLM receives only your input, with no system prompt or role injected.
+- No temperature set: The temperature parameter is not set (unless you explicitly provide `-t`/`--temperature`).
+
+Activate vanilla mode with the CLI flag:
+
+```bash
+python -m janito --vanilla "Your prompt here"
+```
+
+Or in chat shell mode:
+
+```bash
+python -m janito --vanilla
+```
+
+Vanilla mode is ideal for:
+- Testing raw model behavior
+- Comparing LLM output with and without agent guidance
+- Ensuring no agent-side intervention or context is added
+
+> Note: Vanilla mode is a runtime switch and does not change the Agent API or class signatures. It is controlled via CLI/config only.