quantalogic 0.58.0__py3-none-any.whl → 0.59.0__py3-none-any.whl

quantalogic/agent_factory.py

@@ -4,6 +4,12 @@ from loguru import logger
 
 from quantalogic.agent import Agent
 from quantalogic.agent_config import (
+    DuckDuckGoSearchTool,
+    NodeJsTool,
+    PythonTool,
+    SearchDefinitionNames,
+    TaskCompleteTool,
+    WikipediaSearchTool,
     create_basic_agent,
     create_full_agent,
     create_interpreter_agent,
@@ -26,38 +32,19 @@ class AgentRegistry:
 
     @classmethod
     def register_agent(cls, name: str, agent: Agent) -> None:
-        """Register an agent instance with a name.
-
-        Args:
-            name: Unique name for the agent
-            agent: Agent instance to register
-        """
+        """Register an agent instance with a name."""
         if name in cls._agents:
             raise ValueError(f"Agent with name {name} already exists")
         cls._agents[name] = agent
 
     @classmethod
     def get_agent(cls, name: str) -> Agent:
-        """Retrieve a registered agent by name.
-
-        Args:
-            name: Name of the agent to retrieve
-
-        Returns:
-            Registered Agent instance
-
-        Raises:
-            KeyError: If no agent with that name exists
-        """
+        """Retrieve a registered agent by name."""
         return cls._agents[name]
 
     @classmethod
     def list_agents(cls) -> Dict[str, str]:
-        """List all registered agents.
-
-        Returns:
-            Dictionary mapping agent names to their types
-        """
+        """List all registered agents."""
         return {name: type(agent).__name__ for name, agent in cls._agents.items()}
 
 
@@ -75,7 +62,9 @@ def create_agent_for_mode(
     tools: Optional[List[Any]] = None,
     event_emitter: Any = None,
     specific_expertise: str = "",
-    memory: AgentMemory | None = None
+    memory: AgentMemory | None = None,
+    chat_system_prompt: Optional[str] = None,
+    tool_mode: Optional[str] = None,
 ) -> Agent:
     """Create an agent based on the specified mode.
 
@@ -91,6 +80,8 @@ def create_agent_for_mode(
         event_emitter: Optional event emitter to use in the agent
         specific_expertise: Optional specific expertise for the agent
         memory: Optional AgentMemory instance to use in the agent
+        chat_system_prompt: Optional persona for chat mode
+        tool_mode: Optional tool or toolset to prioritize in chat mode
         
     Returns:
         Agent: The created agent instance
@@ -103,8 +94,33 @@ def create_agent_for_mode(
     logger.debug(f"Using no_stream: {no_stream}")
     logger.debug(f"Using compact_every_n_iteration: {compact_every_n_iteration}")
     logger.debug(f"Using max_tokens_working_memory: {max_tokens_working_memory}")
-
-    if mode == "code":
+    logger.debug(f"Using tool_mode: {tool_mode}")
+
+    # Default tools if none provided
+    if tools is None:
+        tools = [TaskCompleteTool()]
+
+    if mode == "chat":
+        logger.debug(f"Creating chat agent with persona: {chat_system_prompt}")
+        # Customize tools based on tool_mode
+        if tool_mode:
+            if tool_mode == "search":
+                tools.extend([DuckDuckGoSearchTool(), WikipediaSearchTool()])
+            elif tool_mode == "code":
+                tools.extend([PythonTool(), NodeJsTool(), SearchDefinitionNames()])
+            elif tool_mode in [t.name for t in tools]:  # Specific tool name
+                tools = [t for t in tools if t.name == tool_mode or isinstance(t, TaskCompleteTool)]
+            else:
+                logger.warning(f"Unknown tool mode '{tool_mode}', using default tools")
+        agent = Agent(
+            model_name=model_name,
+            memory=memory if memory else AgentMemory(),
+            tools=tools,
+            chat_system_prompt=chat_system_prompt,
+            tool_mode=tool_mode,
+        )
+        return agent
+    elif mode == "code":
         logger.debug("Creating code agent without basic mode")
         agent = create_coding_agent(
             model_name,
@@ -116,7 +132,7 @@ def create_agent_for_mode(
             max_tokens_working_memory=max_tokens_working_memory,
         )
         return agent
-    if mode == "code-basic":
+    elif mode == "code-basic":
         agent = create_coding_agent(
             model_name,
             vision_model_name,
@@ -161,7 +177,7 @@ def create_agent_for_mode(
             max_tokens_working_memory=max_tokens_working_memory,
         )
         return agent
-    if mode == "search-full":
+    elif mode == "search-full":
         agent = create_search_agent(
             model_name,
             mode_full=True,
@@ -170,17 +186,5 @@ def create_agent_for_mode(
             max_tokens_working_memory=max_tokens_working_memory,
         )
         return agent
-#    if mode == "custom":
-#        agent = create_custom_agent(
-#            model_name,
-#            vision_model_name,
-#            no_stream=no_stream,
-#            compact_every_n_iteration=compact_every_n_iteration,
-#            max_tokens_working_memory=max_tokens_working_memory,
-#            specific_expertise=specific_expertise,
-#            tools=tools,
-#            memory=memory
-#        )
-#        return agent
     else:
-        raise ValueError(f"Unknown agent mode: {mode}")
+        raise ValueError(f"Unknown agent mode: {mode}")

quantalogic/config.py

@@ -1,18 +1,19 @@
-from dataclasses import dataclass
 from typing import Optional
 
+from pydantic import BaseModel
 
-@dataclass
-class QLConfig:
-    """Central configuration for QuantaLogic agent parameters."""
 
+class QLConfig(BaseModel):
     model_name: str
     verbose: bool
     mode: str
     log: str
-    vision_model_name: Optional[str]
+    vision_model_name: Optional[str] = None
     max_iterations: int
-    compact_every_n_iteration: Optional[int]
-    max_tokens_working_memory: Optional[int]
+    compact_every_n_iteration: Optional[int] = None
+    max_tokens_working_memory: Optional[int] = None
     no_stream: bool
     thinking_model_name: str
+    chat_system_prompt: Optional[str] = None
+    tool_mode: Optional[str] = None  # Added field for tool mode
+    auto_tool_call: bool = True  # Default to True for automatic tool execution

quantalogic/event_emitter.py

@@ -329,9 +329,9 @@ class EventEmitter:
         """
         with self._lock:
             return {
-                "wildcard_listeners": [(l.__name__, p, m) for l, p, m in self._wildcard_listeners],
+                "wildcard_listeners": [(listener.__name__, p, m) for listener, p, m in self._wildcard_listeners],
                 "event_listeners": {
-                    evt: [(l.__name__, p, m) for l, p, m in listeners] for evt, listeners in self._listeners.items()
+                    evt: [(listener.__name__, p, m) for listener, p, m in listeners] for evt, listeners in self._listeners.items()
                 },
             }
 

quantalogic/main.py

@@ -16,7 +16,6 @@ from quantalogic.version import get_version
 # Load environment variables from .env file
 load_dotenv()
 
-
 # Configure logger
 logger.remove()
 
@@ -45,7 +44,7 @@ except ImportError as e:
     termios = None
     tty = None
 
-AGENT_MODES = ["code", "basic", "interpreter", "full", "code-basic", "search", "search-full"]
+AGENT_MODES = ["code", "basic", "interpreter", "full", "code-basic", "search", "search-full", "chat"]  # Added "chat"
 
 
 def setup_terminal():
@@ -104,7 +103,7 @@ def restore_terminal(old_settings):
     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="basic", help="Agent mode (code/search/full).")
+@click.option("--mode", type=click.Choice(AGENT_MODES), default="basic", help="Agent mode (code/search/full/chat).")
 @click.option(
     "--vision-model-name",
     default=None,
@@ -170,6 +169,7 @@ def cli(
             max_tokens_working_memory=max_tokens_working_memory,
             no_stream=False,  # Default value for backward compatibility
             thinking_model_name=thinking_model,
+            chat_system_prompt=None,  # Default to None for non-chat modes
         )
         ctx.invoke(
             task,
@@ -193,7 +193,7 @@ def cli(
     help='Specify the model to use (litellm format, e.g. "openrouter/deepseek/deepseek-chat").',
 )
 @click.option("--verbose", is_flag=True, help="Enable verbose output.")
-@click.option("--mode", type=click.Choice(AGENT_MODES), default="basic", help="Agent mode (code/search/full).")
+@click.option("--mode", type=click.Choice(AGENT_MODES), default="basic", help="Agent mode (code/search/full/chat).")
 @click.option(
     "--log",
     type=click.Choice(["info", "debug", "warning"]),
@@ -263,6 +263,7 @@ def task(
             max_tokens_working_memory=max_tokens_working_memory,
             no_stream=no_stream,
             thinking_model_name=thinking_model,
+            chat_system_prompt=None  # Default to None for task command
         )
 
         task_runner(
@@ -304,6 +305,81 @@ def list_models(search: Optional[str] = None):
         console.print(f"- {model}")
 
 
+@cli.command()
+@click.option(
+    "--persona",
+    default="You are a friendly, helpful AI assistant.",
+    help="Specify the persona for chat mode (e.g., 'You are a witty pirate AI')."
+)
+@click.option(
+    "--model-name",
+    default=MODEL_NAME,
+    help='Specify the model to use (litellm format, e.g. "openai/gpt-4o-mini").',
+)
+@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(
+    "--vision-model-name",
+    default=None,
+    help='Specify the vision model to use (litellm format, e.g. "openrouter/openai/gpt-4o-mini").',
+)
+@click.option(
+    "--no-stream",
+    is_flag=True,
+    help="Disable streaming output (default: streaming enabled).",
+)
+@click.option(
+    "--tool-mode",
+    type=str,
+    default=None,
+    help="Specify a tool or toolset to use in chat mode (e.g., 'search', 'code', or a specific tool name).",
+)
+@click.option(
+    "--auto-tool-call",
+    is_flag=True,
+    default=True,
+    help="Enable automatic tool execution and interpretation in chat mode (default: True).",
+)
+def chat(
+    persona: str,
+    model_name: str,
+    log: str,
+    verbose: bool,
+    vision_model_name: str | None,
+    no_stream: bool,
+    tool_mode: Optional[str],
+    auto_tool_call: bool,
+) -> None:
+    """Start a conversational chat with the QuantaLogic agent."""
+    console = Console()
+    config = QLConfig(
+        model_name=model_name,
+        verbose=verbose,
+        mode="chat",
+        log=log,
+        vision_model_name=vision_model_name,
+        max_iterations=1,  # Chat mode doesn't need iterations
+        compact_every_n_iteration=None,
+        max_tokens_working_memory=None,
+        no_stream=no_stream,
+        thinking_model_name="default",
+        chat_system_prompt=persona,
+        tool_mode=tool_mode,
+        auto_tool_call=auto_tool_call,
+    )
+    try:
+        task_runner(console, None, config, None)
+    except Exception as e:
+        console.print(f"[red]Error in chat mode: {str(e)}[/red]")
+        logger.error(f"Error in chat execution: {e}", exc_info=True)
+        sys.exit(1)
+
+
 def main():
     """Main entry point."""
     old_settings = setup_terminal()
@@ -314,4 +390,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

quantalogic/prompts/chat_system_prompt.j2

@@ -0,0 +1,54 @@
+### Chat System Configuration
+
+#### Agent Persona
+{{ persona }}
+
+You must reply to the user directly, without any additional information except if we must call a tool to execute a task before replying to the user.
+
+#### Tool Usage Guidelines
+
+When using tools, you MUST use the EXACT tool name as shown in the Tools list below. Each tool has specific required parameters.
+
+Tools must be called using the following XML format, with NO additional text:
+
+```xml
+<action>
+<tool_name>  <!-- Use the EXACT tool name from the list below -->
+  <parameter_name>parameter_value</parameter_name>  <!-- Include all required parameters -->
+  <another_parameter>value</another_parameter>  <!-- Optional parameters if needed -->
+</tool_name>
+</action>
+```
+
+#### Examples of Correct Tool Usage
+
+**Example 1 - Search Tool:**
+```xml
+<action>
+<duckduckgo_tool>
+  <query>search query text</query>
+  <max_results>5</max_results>  <!-- Always include max_results for search -->
+</duckduckgo_tool>
+</action>
+```
+
+**Example 2 - Task Completion Tool:**
+```xml
+<action>
+<task_complete>
+  <answer>Your final answer to the task</answer>
+</task_complete>
+</action>
+```
+
+#### Operational Tools Available
+
+{% if tools_prompt != "No tools available." %}
+**Tools Available**:
+{{ tools_prompt | indent(2) }}
+{% else %}
+**Tools Available**: None
+{% endif %}
+
+Don't invent tools that are not listed.
+