quantalogic 0.2.8__py3-none-any.whl → 0.2.12__py3-none-any.whl

quantalogic/main.py

@@ -2,6 +2,7 @@
 """Main module for the QuantaLogic agent."""
 
 # Standard library imports
+import random
 import sys
 from typing import Optional
 
@@ -9,6 +10,9 @@ from typing import Optional
 import click
 from loguru import logger
 
+from quantalogic.utils.check_version import check_if_is_latest_version
+from quantalogic.version import get_version
+
 # Configure logger
 logger.remove()  # Remove default logger
 
@@ -33,34 +37,63 @@ from quantalogic.version import get_version  # noqa: E402
 AGENT_MODES = ["code", "basic", "interpreter", "full", "code-basic"]
 
 
-def create_agent_for_mode(mode: str, model_name: str) -> Agent:
+def create_agent_for_mode(mode: str, model_name: str, vision_model_name: str | None) -> Agent:
     """Create an agent based on the specified mode."""
     logger.debug(f"Creating agent for mode: {mode} with model: {model_name}")
     if mode == "code":
         logger.debug("Creating code agent without basic mode")
-        return create_coding_agent(model_name, basic=False)
+        return create_coding_agent(model_name, vision_model_name, basic=False)
     if mode == "code-basic":
-        return create_coding_agent(model_name, basic=True)
+        return create_coding_agent(model_name, vision_model_name, basic=True)
     elif mode == "basic":
-        return create_orchestrator_agent(model_name)
+        return create_orchestrator_agent(model_name, vision_model_name)
     elif mode == "full":
-        return create_full_agent(model_name)
+        return create_full_agent(model_name, vision_model_name)
     elif mode == "interpreter":
-        return create_interpreter_agent(model_name)
+        return create_interpreter_agent(model_name, vision_model_name)
     else:
         raise ValueError(f"Unknown agent mode: {mode}")
 
+def check_new_version():
+    # Randomly check for updates (1 in 10 chance)
+    if random.randint(1, 10) == 1:
+        try:
+            current_version = get_version()
+            has_new_version, latest_version = check_if_is_latest_version()
+
+            if has_new_version:
+                console = Console()
+                console.print(
+                    Panel.fit(
+                        f"[yellow]⚠️  Update Available![/yellow]\n\n"
+                        f"Current version: [bold]{current_version}[/bold]\n"
+                        f"Latest version: [bold]{latest_version}[/bold]\n\n"
+                        "To update, run:\n"
+                        "[bold]pip install --upgrade quantalogic[/bold]\n"
+                        "or if using pipx:\n"
+                        "[bold]pipx upgrade quantalogic[/bold]",
+                        title="[bold]Update Available[/bold]",
+                        border_style="yellow",
+                    )
+                )
+        except Exception:
+            return
 
 def configure_logger(log_level: str) -> None:
     """Configure the logger with the specified log level and format."""
     logger.remove()
-    logger.add(sys.stderr, level=log_level.upper(), format="{time} | {level} | {message}")
-    logger.info(f"Log level set to: {log_level}")
+    logger.add(
+        sys.stderr,
+        level=log_level.upper(),
+        format="<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{process}</cyan> | <magenta>{file}:{line}</magenta> | {message}",
+    )
+    logger.debug(f"Log level set to: {log_level}")
 
 
 def set_litellm_verbose(verbose_mode: bool) -> None:
     """Set the verbosity of the litellm library."""
     import litellm
+
     litellm.set_verbose = verbose_mode
 
 
@@ -87,7 +120,7 @@ def get_task_from_file(file_path: str) -> str:
         raise Exception(f"Unexpected error reading file: {e}")
 
 
-def display_welcome_message(console: Console, model_name: str) -> None:
+def display_welcome_message(console: Console, model_name: str, vision_model_name: str | None) -> None:
     """Display the welcome message and instructions."""
     version = get_version()
     console.print(
@@ -97,9 +130,10 @@ def display_welcome_message(console: Console, model_name: str) -> None:
             "1. [bold]Describe your task[/bold]: Tell the AI what you need help with.\n"
             "2. [bold]Submit your task[/bold]: Press [bold]Enter[/bold] twice to send your request.\n\n"
             "3. [bold]Exit the app[/bold]: Leave the input blank and press [bold]Enter[/bold] twice to close the assistant.\n\n"
-            f"[yellow]ℹ️ System Info:[/yellow]\n\n"
-            f"- Version: {get_version()}\n"
-            f"- Model: {model_name}\n\n"
+            f"[yellow] 🤖 System Info:[/yellow]\n\n"
+            "\n"
+            f"- Model: {model_name}\n"
+            f"- Vision Model: {vision_model_name}\n\n"
             "[bold magenta]💡 Pro Tips:[/bold magenta]\n\n"
             "- Be as specific as possible in your task description to get the best results!\n"
             "- Use clear and concise language when describing your task\n"
@@ -118,18 +152,38 @@ def display_welcome_message(console: Console, model_name: str) -> None:
     default=MODEL_NAME,
     help='Specify the model to use (litellm format, e.g. "openrouter/deepseek-chat").',
 )
-@click.option("--log", type=click.Choice(["info", "debug", "warning"]), default="info", help="Set logging level (info/debug/warning).")
+@click.option(
+    "--log",
+    type=click.Choice(["info", "debug", "warning"]),
+    default="info",
+    help="Set logging level (info/debug/warning).",
+)
 @click.option("--verbose", is_flag=True, help="Enable verbose output.")
 @click.option("--mode", type=click.Choice(AGENT_MODES), default="code", help="Agent mode (code/search/full).")
+@click.option(
+    "--vision-model-name",
+    default=None,
+    help='Specify the vision model to use (litellm format, e.g. "openrouter/A/gpt-4o-mini").',
+)
 @click.pass_context
-def cli(ctx: click.Context, version: bool, model_name: str, verbose: bool, mode: str, log: str) -> None:
+def cli(
+    ctx: click.Context,
+    version: bool,
+    model_name: str,
+    verbose: bool,
+    mode: str,
+    log: str,
+    vision_model_name: str | None,
+) -> None:
     """QuantaLogic AI Assistant - A powerful AI tool for various tasks."""
     if version:
         console = Console()
         console.print(f"QuantaLogic version: {get_version()}")
         sys.exit(0)
     if ctx.invoked_subcommand is None:
-        ctx.invoke(task, model_name=model_name, verbose=verbose, mode=mode, log=log)
+        ctx.invoke(
+            task, model_name=model_name, verbose=verbose, mode=mode, log=log, vision_model_name=vision_model_name
+        )
 
 
 @cli.command()
@@ -141,24 +195,45 @@ def cli(ctx: click.Context, version: bool, model_name: str, verbose: bool, mode:
 )
 @click.option("--verbose", is_flag=True, help="Enable verbose output.")
 @click.option("--mode", type=click.Choice(AGENT_MODES), default="code", help="Agent mode (code/search/full).")
-@click.option("--log", type=click.Choice(["info", "debug", "warning"]), default="info", help="Set logging level (info/debug/warning).")
+@click.option(
+    "--log",
+    type=click.Choice(["info", "debug", "warning"]),
+    default="info",
+    help="Set logging level (info/debug/warning).",
+)
+@click.option(
+    "--vision-model-name",
+    default=None,
+    help='Specify the vision model to use (litellm format, e.g. "openrouter/openai/gpt-4o-mini").',
+)
 @click.argument("task", required=False)
-def task(file: Optional[str], model_name: str, verbose: bool, mode: str, log: str, task: Optional[str]) -> None:
+def task(
+    file: Optional[str],
+    model_name: str,
+    verbose: bool,
+    mode: str,
+    log: str,
+    vision_model_name: str | None,
+    task: Optional[str],
+) -> None:
     """Execute a task with the QuantaLogic AI Assistant."""
     console = Console()
     switch_verbose(verbose, log)
 
+
     try:
         if file:
             task_content = get_task_from_file(file)
         else:
             if task:
+                check_new_version()
                 task_content = task
             else:
-                display_welcome_message(console, model_name)
-                logger.info("Waiting for user input...")
+                display_welcome_message(console, model_name, vision_model_name)
+                check_new_version()
+                logger.debug("Waiting for user input...")
                 task_content = get_multiline_input(console).strip()
-                logger.info(f"User input received. Task content: {task_content}")
+                logger.debug(f"User input received. Task content: {task_content}")
                 if not task_content:
                     logger.info("No task provided. Exiting...")
                     console.print("[yellow]No task provided. Exiting...[/yellow]")
@@ -172,12 +247,20 @@ def task(file: Optional[str], model_name: str, verbose: bool, mode: str, log: st
                     border_style="blue",
                 )
             )
-            if not Confirm.ask("[bold]Are you sure you want to submit this task?[/bold]"):
-                console.print("[yellow]Task submission cancelled. Exiting...[/yellow]")
-                sys.exit(0)
+        if not Confirm.ask("[bold]Are you sure you want to submit this task?[/bold]"):
+            console.print("[yellow]Task submission cancelled. Exiting...[/yellow]")
+            sys.exit(0)
+
+        console.print(
+            Panel.fit(
+                "[green]✓ Task successfully submitted! Processing...[/green]",
+                title="[bold]Status[/bold]",
+                border_style="green",
+            )
+        )
 
         logger.debug(f"Creating agent for mode: {mode} with model: {model_name}")
-        agent = create_agent_for_mode(mode, model_name)
+        agent = create_agent_for_mode(mode, model_name, vision_model_name=vision_model_name)
         logger.debug(f"Created agent for mode: {mode} with model: {model_name}")
 
         events = [
@@ -215,7 +298,7 @@ def task(file: Optional[str], model_name: str, verbose: bool, mode: str, log: st
 
 
 def main():
-    """Entry point for the quantalogic CLI."""
+    """Main Entry point"""
     cli()
 
 

quantalogic/print_event.py

@@ -1,12 +1,14 @@
 """Print events with rich formatting."""
 
+from typing import Any
+
 from rich import box
 from rich.console import Console
 from rich.panel import Panel
 from rich.tree import Tree
 
 
-def console_print_events(event: str, data: dict[str, any] = None):
+def console_print_events(event: str, data: dict[str, Any] | None = None):
     """Print events with rich formatting.
 
     Args:

quantalogic/prompts.py

@@ -14,11 +14,10 @@ Tasks will be presented within XML tags:
 ### Response Protocol
 Every response must contain exactly two XML blocks:
 
-Be very concise and very precise in the <thinking> block
-
 1. Analysis Block:
 ```xml
 <thinking>
+  <!-- You must follow this precise format, be very concise and very precise -->
  <task_analysis_if_no_history> 
    Only if no conversation history:
     * Rewrite the <task> and its context with your own words in detailed, clear, and specific manner.
@@ -51,20 +50,24 @@ Be very concise and very precise in the <thinking> block
     </result>
   </last_observation>
   <progess_analysis>
+     <!-- if there is a conversation history -->
     * Detail each step failed and completed so far.
     * Identify and evaluate any blockers or challenges to the progress of global task.
+    * Identify repetitions: if repeated steps, take a step back and rethink your approach.
     * Provide potential solutions, and if needed, suggest reevaluating the approach and the plan.
   </progess_analysis>
   <variables>
+      <!-- if there is a conversation history -->
     * List all variable names and concisely describe their current values.
   </variables>
   <next_steps>
     * Outline immediate actions required.
     * Justify tool selection and parameter choices.
-    * Think about variable interpolation to minimize generation of tokens.
-    * Consider alternatives if previous attempts were unsuccessful.
+    * Prefer variable interpolation if possible, to minimize generation of tokens.
+    * Consider alternatives, take a step back if previous attempts were unsuccessful to review the plan.
   </next_steps>
   <taskpad>
+    <!-- optional -->
     <note>Use this to record notes about intermediate steps.</note>
   </taskpad>
 </thinking>
@@ -73,25 +76,15 @@ Be very concise and very precise in the <thinking> block
 2. Action Block:
 ```xml
 <tool_name>
-    <parameter1>value1</parameter1>
+    <!-- tool_name is the name of the tool from available tools -->
+    <parameter1>
+      <!-- Use variable interpolation to pass context to minimize generation of tokens, example: <content>$var1$<</content> -->
+      value1
+    </parameter1>
     <parameter2>value2</parameter2>
 </tool_name>
 ```
 
-### Tool Usage Guidelines
-1. Before Repeating a Tool Call:
-   - Review previous results in detail.
-   - State why a repeat is needed.
-   - Adjust parameters if necessary.
-   - Consider whether other tools are more appropriate.
-   - Use variable interpolation to pass context to minimize generation of tokens, example: <toolname>$var1$<</toolname>
-
-2. When Tool Calls Fail:
-   - Examine the error message carefully.
-   - Adjust parameters if needed.
-   - Consider alternative tools.
-   - Break down complex processes into smaller steps if necessary.
-
 ### Available Tools
 {tools}
 

quantalogic/server/agent_server.py

@@ -47,7 +47,7 @@ VALIDATION_TIMEOUT = 30.0  # seconds
 
 def handle_sigterm(signum, frame):
     """Handle SIGTERM signal."""
-    logger.info("Received SIGTERM signal")
+    logger.debug("Received SIGTERM signal")
     raise SystemExit(0)
 
 
@@ -74,7 +74,7 @@ class ServerState:
     async def initiate_shutdown(self, force: bool = False):
         """Initiate the shutdown process."""
         if not self.is_shutting_down or force:
-            logger.info("Initiating server shutdown...")
+            logger.debug("Initiating server shutdown...")
             self.is_shutting_down = True
             self.force_exit = force
             self.shutdown_initiated.set()
@@ -88,7 +88,7 @@ class ServerState:
         """Handle interrupt signal."""
         self.interrupt_count += 1
         if self.interrupt_count == 1:
-            logger.info("Graceful shutdown initiated (press Ctrl+C again to force)")
+            logger.debug("Graceful shutdown initiated (press Ctrl+C again to force)")
             asyncio.create_task(self.initiate_shutdown(force=False))
         else:
             logger.warning("Forced shutdown initiated...")
@@ -277,7 +277,7 @@ class AgentState:
             # Override ask_for_user_validation with SSE-based method
             self.agent.ask_for_user_validation = self.sse_ask_for_user_validation
 
-            logger.info(f"Agent initialized with model: {model_name}")
+            logger.debug(f"Agent initialized with model: {model_name}")
         except Exception as e:
             logger.error(f"Failed to initialize agent: {e}", exc_info=True)
             raise
@@ -316,7 +316,7 @@ class AgentState:
             console_print_events(event_type, data)
 
             # Log event details
-            logger.info(f"Agent Event: {event_type}")
+            logger.debug(f"Agent Event: {event_type}")
             logger.debug(f"Event Data: {data}")
 
             # Broadcast to clients
@@ -334,7 +334,7 @@ class AgentState:
     async def cleanup(self):
         """Clean up resources during shutdown."""
         try:
-            logger.info("Cleaning up resources...")
+            logger.debug("Cleaning up resources...")
             if server_state.force_exit:
                 logger.warning("Forced cleanup - skipping graceful shutdown")
                 return
@@ -349,7 +349,7 @@ class AgentState:
                     self.validation_responses.clear()
                 # Clear agent
                 self.agent = None
-                logger.info("Cleanup completed")
+                logger.debug("Cleanup completed")
         except TimeoutError:
             logger.warning(f"Cleanup timed out after {SHUTDOWN_TIMEOUT} seconds")
         except Exception as e:
@@ -429,7 +429,7 @@ class AgentState:
         with self.queue_lock:
             if task_id in self.task_queues:
                 del self.task_queues[task_id]
-                logger.info(f"Removed event queue for task_id: {task_id}")
+                logger.debug(f"Removed event queue for task_id: {task_id}")
 
 
 # Initialize global states
@@ -448,11 +448,11 @@ async def lifespan(app: FastAPI):
             loop.add_signal_handler(sig, lambda s=sig: asyncio.create_task(handle_shutdown(s)))
         yield
     finally:
-        logger.info("Shutting down server gracefully...")
+        logger.debug("Shutting down server gracefully...")
         await server_state.initiate_shutdown()
         await agent_state.cleanup()
         server_state.shutdown_complete.set()
-        logger.info("Server shutdown complete")
+        logger.debug("Server shutdown complete")
 
 
 async def handle_shutdown(sig):
@@ -527,7 +527,7 @@ async def event_stream(request: Request, task_id: Optional[str] = None) -> Strea
     async def event_generator() -> AsyncGenerator[str, None]:
         # Ensure unique client-task combination
         client_id = agent_state.add_client(task_id)
-        logger.info(f"Client {client_id} subscribed to {'task_id: ' + task_id if task_id else 'all events'}")
+        logger.debug(f"Client {client_id} subscribed to {'task_id: ' + task_id if task_id else 'all events'}")
 
         try:
             while not server_state.is_shutting_down:
@@ -557,7 +557,7 @@ async def event_stream(request: Request, task_id: Optional[str] = None) -> Strea
         finally:
             # Clean up the client's event queue
             agent_state.remove_client(client_id, task_id)
-            logger.info(f"Client {client_id} {'unsubscribed from task_id: ' + task_id if task_id else 'disconnected'}")
+            logger.debug(f"Client {client_id} {'unsubscribed from task_id: ' + task_id if task_id else 'disconnected'}")
 
     return StreamingResponse(
         event_generator(),
@@ -629,5 +629,5 @@ if __name__ == "__main__":
     try:
         server.run()
     except KeyboardInterrupt:
-        logger.info("Received keyboard interrupt")
+        logger.debug("Received keyboard interrupt")
         sys.exit(1)

quantalogic/server/state.py

@@ -35,7 +35,7 @@ class ServerState:
     async def initiate_shutdown(self, force: bool = False):
         """Initiate the shutdown process."""
         if not self.is_shutting_down or force:
-            logger.info("Initiating server shutdown...")
+            logger.debug("Initiating server shutdown...")
             self.is_shutting_down = True
             self.force_exit = force
             self.shutdown_initiated.set()
@@ -48,7 +48,7 @@ class ServerState:
         """Handle interrupt signal."""
         self.interrupt_count += 1
         if self.interrupt_count == 1:
-            logger.info("Graceful shutdown initiated (press Ctrl+C again to force)")
+            logger.debug("Graceful shutdown initiated (press Ctrl+C again to force)")
             asyncio.create_task(self.initiate_shutdown(force=False))
         else:
             logger.warning("Forced shutdown initiated...")
@@ -95,7 +95,7 @@ class AgentState:
                 if task_id not in self.agents:
                     self.agents[task_id] = self.create_agent_for_task(task_id)
 
-            logger.info(f"New client connected: {client_id} for task: {task_id}")
+            logger.debug(f"New client connected: {client_id} for task: {task_id}")
             return client_id
 
     def create_agent_for_task(self, task_id: str) -> Any:
@@ -109,7 +109,7 @@ class AgentState:
         """
         # Placeholder for agent creation logic
         agent = ...  # Replace with actual agent creation logic
-        logger.info(f"Agent created for task: {task_id}")
+        logger.debug(f"Agent created for task: {task_id}")
         return agent
 
     def get_agent_for_task(self, task_id: str) -> Optional[Any]:
@@ -128,7 +128,7 @@ class AgentState:
         with self.queue_lock:
             if client_id in self.event_queues:
                 del self.event_queues[client_id]
-                logger.info(f"Client disconnected: {client_id}")
+                logger.debug(f"Client disconnected: {client_id}")
 
     def _format_data_for_client(self, data: Dict[str, Any]) -> Dict[str, Any]:
         """Format data for client consumption."""

quantalogic/tool_manager.py

@@ -18,18 +18,18 @@ class ToolManager(BaseModel):
 
     def add(self, tool: Tool):
         """Add a tool to the tool dictionary."""
-        logger.info(f"Adding tool: {tool.name} to tool dictionary")
+        logger.debug(f"Adding tool: {tool.name} to tool dictionary")
         self.tools[tool.name] = tool
 
     def add_list(self, tools: list[Tool]):
         """Add a list of tools to the tool dictionary."""
-        logger.info(f"Adding {len(tools)} tools to tool dictionary")
+        logger.debug(f"Adding {len(tools)} tools to tool dictionary")
         for tool in tools:
             self.add(tool)
 
     def remove(self, tool_name: str) -> bool:
         """Remove a tool from the tool dictionary."""
-        logger.info(f"Removing tool: {tool_name} from tool dictionary")
+        logger.debug(f"Removing tool: {tool_name} from tool dictionary")
         del self.tools[tool_name]
         return True
 
@@ -45,7 +45,7 @@ class ToolManager(BaseModel):
 
     def execute(self, tool_name: str, **kwargs) -> str:
         """Execute a tool from the tool dictionary."""
-        logger.info(f"Executing tool: {tool_name} with arguments: {kwargs}")
+        logger.debug(f"Executing tool: {tool_name} with arguments: {kwargs}")
         try:
             result = self.tools[tool_name].execute(**kwargs)
             logger.debug(f"Tool {tool_name} execution completed successfully")

quantalogic/tools/__init__.py

@@ -8,6 +8,7 @@ from .execute_bash_command_tool import ExecuteBashCommandTool
 from .input_question_tool import InputQuestionTool
 from .list_directory_tool import ListDirectoryTool
 from .llm_tool import LLMTool
+from .llm_vision_tool import LLMVisionTool
 from .markitdown_tool import MarkitdownTool
 from .nodejs_tool import NodeJsTool
 from .python_tool import PythonTool
@@ -30,6 +31,7 @@ __all__ = [
     "InputQuestionTool",
     "ListDirectoryTool",
     "LLMTool",
+    "LLMVisionTool",
     "ExecuteBashCommandTool",
     "PythonTool",
     "ElixirTool",

quantalogic/tools/agent_tool.py

@@ -49,7 +49,7 @@ class AgentTool(Tool):
     )
 
     @model_validator(mode="before")
-    def validate_agent(cls, values: dict[str, Any]) -> dict[str, Any]:
+    def validate_agent(cls, values: dict[str, Any]) -> dict[str, Any]:  # noqa: N805
         """Validate the provided agent and its role."""
         agent = values.get("agent")
         # Lazy import to avoid circular dependency

quantalogic/tools/elixir_tool.py

@@ -122,7 +122,7 @@ end
 
 # Execute the main function
 ElixirScript.main()
-""" % script.strip()
+""" % script.strip()  # noqa: UP031
 
         with open(script_path, "w", encoding="utf-8") as f:
             f.write(wrapped_script.strip())

quantalogic/tools/llm_tool.py

@@ -17,11 +17,11 @@ class LLMTool(Tool):
     description: str = Field(
         default=(
             "Generates answers to questions using a specified language model. "
-            "Note: This tool operates in isolation and does not have access to: "
+            "Note: This tool operates in total isolation and does not have access to: "
             " - Memory: All context must be explicitly provided in the prompt. "
             " - File system."
             " - Variables: Any required variables should be interpolated into the prompt (e.g., $var1$). "
-            " - Other tools: It cannot invoke or interact with other tools. "
+            " - No access to Tools, URL, file, or other external resources. "
             "Ensure all necessary information is included directly in your prompt."
         )
     )
@@ -54,6 +54,7 @@ class LLMTool(Tool):
 
     model_name: str = Field(..., description="The name of the language model to use")
     generative_model: GenerativeModel | None = Field(default=None)
+    system_prompt: str | None = Field(default=None)
 
     def model_post_init(self, __context):
         """Initialize the generative model after model initialization."""
@@ -61,7 +62,10 @@ class LLMTool(Tool):
             self.generative_model = GenerativeModel(model=self.model_name)
             logging.debug(f"Initialized LLMTool with model: {self.model_name}")
 
-    def execute(self, system_prompt: str, prompt: str, temperature: str = "0.7") -> str:
+
+    def execute(
+        self, system_prompt: str | None = None, prompt: str | None = None, temperature: str | None = None
+    ) -> str:
         """Execute the tool to generate an answer based on the provided question.
 
         Args:
@@ -84,9 +88,11 @@ class LLMTool(Tool):
             logging.error(f"Invalid temperature value: {temperature}")
             raise ValueError(f"Invalid temperature value: {temperature}") from ve
 
+        used_system_prompt = self.system_prompt if self.system_prompt else system_prompt
+
         # Prepare the messages history
         messages_history = [
-            Message(role="system", content=system_prompt),
+            Message(role="system", content=used_system_prompt),
             Message(role="user", content=prompt),
         ]
 
@@ -111,9 +117,12 @@ class LLMTool(Tool):
 
 if __name__ == "__main__":
     # Example usage of LLMTool
-    tool = LLMTool(model_name="gpt-4o-mini")
+    tool = LLMTool(model_name="openrouter/openai/gpt-4o-mini")
     system_prompt = 'Answer the question as truthfully as possible using the provided context, and if the answer is not contained within the context, say "I don\'t know".'
     question = "What is the meaning of life?"
     temperature = "0.7"
     answer = tool.execute(system_prompt=system_prompt, prompt=question, temperature=temperature)
     print(answer)
+    pirate = LLMTool(model_name="openrouter/openai/gpt-4o-mini", system_prompt="You are a pirate.")
+    pirate_answer = pirate.execute(system_prompt=system_prompt, prompt=question, temperature=temperature)
+    print(pirate_answer)