quantalogic 0.2.15__py3-none-any.whl → 0.2.17__py3-none-any.whl

quantalogic/__init__.py

@@ -11,10 +11,11 @@ warnings.filterwarnings(
 
 
 from .agent import Agent  # noqa: E402
+from .console_print_events import console_print_events  # noqa: E402
+from .console_print_token import console_print_token  # noqa: E402
 from .event_emitter import EventEmitter  # noqa: E402
 from .memory import AgentMemory, VariableMemory  # noqa: E402
-from .print_event import console_print_events  # noqa: E402
 
 """QuantaLogic package for AI-powered generative models."""
 
-__all__ = ["Agent", "EventEmitter", "AgentMemory", "VariableMemory", "console_print_events"]
+__all__ = ["Agent", "EventEmitter", "AgentMemory", "VariableMemory", "console_print_events","console_print_token"]

quantalogic/agent.py

@@ -8,7 +8,7 @@ from loguru import logger
 from pydantic import BaseModel, ConfigDict
 
 from quantalogic.event_emitter import EventEmitter
-from quantalogic.generative_model import GenerativeModel
+from quantalogic.generative_model import GenerativeModel, ResponseStats, TokenUsage
 from quantalogic.memory import AgentMemory, Message, VariableMemory
 from quantalogic.prompts import system_prompt
 from quantalogic.tool_manager import ToolManager
@@ -85,6 +85,9 @@ class Agent(BaseModel):
         """Initialize the agent with model, memory, tools, and configurations."""
         try:
             logger.debug("Initializing agent...")
+            # Create event emitter first
+            event_emitter = EventEmitter()
+
             # Add TaskCompleteTool to the tools list if not already present
             if TaskCompleteTool() not in tools:
                 tools.append(TaskCompleteTool())
@@ -108,7 +111,7 @@ class Agent(BaseModel):
 
             logger.debug("Base class init started ...")
             super().__init__(
-                model=GenerativeModel(model=model_name),
+                model=GenerativeModel(model=model_name, event_emitter=event_emitter),
                 memory=memory,
                 variable_store=VariableMemory(),
                 tools=tool_manager,
@@ -116,19 +119,21 @@ class Agent(BaseModel):
                 ask_for_user_validation=ask_for_user_validation,
                 task_to_solve=task_to_solve,
                 specific_expertise=specific_expertise,
+                event_emitter=event_emitter,
             )
             logger.debug("Agent initialized successfully.")
         except Exception as e:
             logger.error(f"Failed to initialize agent: {str(e)}")
             raise
 
-    def solve_task(self, task: str, max_iterations: int = 30) -> str:
+    def solve_task(self, task: str, max_iterations: int = 30, streaming: bool = False) -> str:
         """Solve the given task using the ReAct framework.
 
         Args:
             task (str): The task description.
             max_iterations (int, optional): Maximum number of iterations to attempt solving the task.
                 Defaults to 30 to prevent infinite loops and ensure timely task completion.
+            streaming (bool, optional): Whether to use streaming mode for generating responses.
 
         Returns:
             str: The final response after task completion.
@@ -172,11 +177,34 @@ class Agent(BaseModel):
 
                 self._compact_memory_if_needed(current_prompt)
 
-                result = self.model.generate_with_history(messages_history=self.memory.memory, prompt=current_prompt)
+                if streaming:
+                    # For streaming, collect the response chunks
+                    content = ""
+                    for chunk in self.model.generate_with_history(
+                        messages_history=self.memory.memory, prompt=current_prompt, streaming=True
+                    ):
+                        content += chunk
+
+                    # Create a response object similar to non-streaming mode
+                    result = ResponseStats(
+                        response=content,
+                        usage=TokenUsage(
+                            prompt_tokens=0,  # We don't have token counts in streaming mode
+                            completion_tokens=0,
+                            total_tokens=0,
+                        ),
+                        model=self.model.model,
+                        finish_reason="stop",
+                    )
+                else:
+                    result = self.model.generate_with_history(
+                        messages_history=self.memory.memory, prompt=current_prompt, streaming=False
+                    )
 
                 content = result.response
-                token_usage = result.usage
-                self.total_tokens = token_usage.total_tokens
+                if not streaming:  # Only update tokens for non-streaming mode
+                    token_usage = result.usage
+                    self.total_tokens = token_usage.total_tokens
 
                 # Emit event: Task Think End
                 self._emit_event(
@@ -187,7 +215,7 @@ class Agent(BaseModel):
                 )
 
                 # Process the assistant's response
-                result = self._observe_response(result.response, iteration=self.current_iteration)
+                result = self._observe_response(content, iteration=self.current_iteration)
 
                 current_prompt = result.next_prompt
 
@@ -292,9 +320,10 @@ class Agent(BaseModel):
                 is_repeated_call = self._is_repeated_tool_call(tool_name, arguments_with_values)
 
                 if is_repeated_call:
-                    return self._handle_repeated_tool_call(tool_name, arguments_with_values)
+                    executed_tool, response = self._handle_repeated_tool_call(tool_name, arguments_with_values)
+                else:
+                    executed_tool, response = self._execute_tool(tool_name, tool, arguments_with_values)
 
-                executed_tool, response = self._execute_tool(tool_name, tool, arguments_with_values)
                 if not executed_tool:
                     return self._handle_tool_execution_failure(response)
 
@@ -406,7 +435,7 @@ class Agent(BaseModel):
 
         formatted_response = (
             "\n"
-            f"--- Observations for iteration {iteration} ---\n"
+            f"--- Observations for iteration {iteration} / max {self.max_iterations} ---\n"
             "\n"
             f"\n --- Tool execution result stored in variable ${variable_name}$ --- \n"
             "\n"
@@ -427,34 +456,26 @@ class Agent(BaseModel):
 
         # Format the response message
         formatted_response = (
-            "\n"
-            f"--- Observations for iteration {iteration} ---\n"
-            "\n"
-            f"\n --- Tool execution result stored in variable ${variable_name}$ --- \n"
-            "\n"
-            f"<{variable_name}>\n{response_display}\n</{variable_name}>\n" + "\n"
-            "\n"
-            f"--- Tools --- \n"
-            "\n"
-            f"{self._get_tools_names_prompt()}"
-            "\n"
-            f"--- Variables --- \n"
-            "\n"
-            f"{self._get_variable_prompt()}"
-            "\n"
-            "You must analyze this answer and evaluate what to do next to solve the task.\n"
-            "If the step failed, take a step back and rethink your approach.\n"
-            "\n"
-            "--- Task to solve summary ---\n"
-            "\n"
-            f"{self.task_to_solve_summary}"
-            "\n"
+            f"\n--- Observations for iteration {iteration} / max {self.max_iterations} ---\n"
+            f"\n--- Tool execution result in ${variable_name}$ ---\n"
+            f"<{variable_name}>\n{response_display}\n</{variable_name}>\n\n"
+            f"--- Tools ---\n{self._get_tools_names_prompt()}\n"
+            f"--- Variables ---\n{self._get_variable_prompt()}\n"
+            "Analyze this response to determine the next steps. If the step failed, reconsider your approach.\n"
+            f"--- Task to solve summary ---\n{self.task_to_solve_summary}\n"
             "--- Format ---\n"
-            "\n"
-            "You MUST respond with exactly two XML blocks formatted in markdown:\n"
-            "\n"
-            " - One <thinking> block detailing your analysis,\n"
-            " - One <tool_name> block specifying the chosen tool and its arguments, as outlined in the system prompt.\n"
+            "Respond only with two XML blocks in markdown as specified in system prompt.\n"
+            "No extra comments must be added.\n"
+            "```xml\n"
+            "<thinking>\n"
+            "...\n"
+            "</thinking>\n"
+            "```\n"
+            "```xml\n"
+            "< ...tool_name... >\n"
+            "...\n"
+            "</ ...tool_name... >\n"
+            "```"
         )
 
         return formatted_response

quantalogic/agent_config.py

@@ -5,9 +5,11 @@
 # Local application imports
 from quantalogic.agent import Agent
 from quantalogic.coding_agent import create_coding_agent
+from quantalogic.console_print_token import console_print_token
 from quantalogic.tools import (
     AgentTool,
     DownloadHttpFileTool,
+    DuckDuckGoSearchTool,
     EditWholeContentTool,
     ExecuteBashCommandTool,
     InputQuestionTool,
@@ -23,20 +25,20 @@ from quantalogic.tools import (
     RipgrepTool,
     SearchDefinitionNames,
     TaskCompleteTool,
-    WriteFileTool,
-    DuckDuckGoSearchTool,
     WikipediaSearchTool,
+    WriteFileTool,
 )
 
 MODEL_NAME = "deepseek/deepseek-chat"
 
 
-def create_agent(model_name: str, vision_model_name: str | None) -> Agent:
+def create_agent(model_name: str, vision_model_name: str | None, no_stream: bool = False) -> Agent:
     """Create an agent with the specified model and tools.
 
     Args:
         model_name (str): Name of the model to use
         vision_model_name (str | None): Name of the vision model to use
+        no_stream (bool, optional): If True, the agent will not stream results.
 
     Returns:
         Agent: An agent with the specified model and tools
@@ -54,12 +56,12 @@ def create_agent(model_name: str, vision_model_name: str | None) -> Agent:
         RipgrepTool(),
         SearchDefinitionNames(),
         MarkitdownTool(),
-        LLMTool(model_name=model_name),
+        LLMTool(model_name=model_name, on_token=console_print_token if not no_stream else None),
         DownloadHttpFileTool(),
     ]
 
     if vision_model_name:
-        tools.append(LLMVisionTool(model_name=vision_model_name))
+        tools.append(LLMVisionTool(model_name=vision_model_name, on_token=console_print_token if not no_stream else None))
 
     return Agent(
         model_name=model_name,
@@ -67,12 +69,13 @@ def create_agent(model_name: str, vision_model_name: str | None) -> Agent:
     )
 
 
-def create_interpreter_agent(model_name: str, vision_model_name: str | None) -> Agent:
+def create_interpreter_agent(model_name: str, vision_model_name: str | None, no_stream: bool = False) -> Agent:
     """Create an interpreter agent with the specified model and tools.
 
     Args:
         model_name (str): Name of the model to use
         vision_model_name (str | None): Name of the vision model to use
+        no_stream (bool, optional): If True, the agent will not stream results.
 
     Returns:
         Agent: An interpreter agent with the specified model and tools
@@ -92,18 +95,19 @@ def create_interpreter_agent(model_name: str, vision_model_name: str | None) ->
         NodeJsTool(),
         SearchDefinitionNames(),
         MarkitdownTool(),
-        LLMTool(model_name=model_name),
+        LLMTool(model_name=model_name, on_token=console_print_token if not no_stream else None),
         DownloadHttpFileTool(),
     ]
     return Agent(model_name=model_name, tools=tools)
 
 
-def create_full_agent(model_name: str, vision_model_name: str | None) -> Agent:
+def create_full_agent(model_name: str, vision_model_name: str | None, no_stream: bool = False) -> Agent:
     """Create an agent with the specified model and many tools.
 
     Args:
         model_name (str): Name of the model to use
         vision_model_name (str | None): Name of the vision model to use
+        no_stream (bool, optional): If True, the agent will not stream results.
 
     Returns:
         Agent: An agent with the specified model and tools
@@ -124,14 +128,14 @@ def create_full_agent(model_name: str, vision_model_name: str | None) -> Agent:
         NodeJsTool(),
         SearchDefinitionNames(),
         MarkitdownTool(),
-        LLMTool(model_name=model_name),
+        LLMTool(model_name=model_name, on_token=console_print_token if not no_stream else None),
         DownloadHttpFileTool(),
         WikipediaSearchTool(),
         DuckDuckGoSearchTool(),
     ]
 
     if vision_model_name:
-        tools.append(LLMVisionTool(model_name=vision_model_name))
+        tools.append(LLMVisionTool(model_name=vision_model_name,on_token=console_print_token if not no_stream else None))
 
     return Agent(
         model_name=model_name,
@@ -139,12 +143,13 @@ def create_full_agent(model_name: str, vision_model_name: str | None) -> Agent:
     )
 
 
-def create_orchestrator_agent(model_name: str, vision_model_name: str | None = None) -> Agent:
+def create_orchestrator_agent(model_name: str, vision_model_name: str | None = None, no_stream: bool = False) -> Agent:
     """Create an agent with the specified model and tools.
 
     Args:
         model_name (str): Name of the model to use
         vision_model_name (str | None): Name of the vision model to use
+        no_stream (bool, optional): If True, the agent will not stream results.
 
     Returns:
         Agent: An agent with the specified model and tools
@@ -160,12 +165,12 @@ def create_orchestrator_agent(model_name: str, vision_model_name: str | None = N
         ReadFileBlockTool(),
         RipgrepTool(),
         SearchDefinitionNames(),
-        LLMTool(model_name=MODEL_NAME),
+        LLMTool(model_name=model_name, on_token=console_print_token if not no_stream else None),
         AgentTool(agent=coding_agent_instance, agent_role="software expert", name="coder_agent_tool"),
     ]
 
     if vision_model_name:
-        tools.append(LLMVisionTool(model_name=vision_model_name))
+        tools.append(LLMVisionTool(model_name=vision_model_name, on_token=console_print_token if not no_stream else None))
 
     return Agent(
         model_name=model_name,

quantalogic/coding_agent.py

@@ -1,5 +1,7 @@
 from quantalogic.agent import Agent
+from quantalogic.console_print_token import console_print_token
 from quantalogic.tools import (
+    DuckDuckGoSearchTool,
     EditWholeContentTool,
     ExecuteBashCommandTool,
     InputQuestionTool,
@@ -18,13 +20,14 @@ from quantalogic.utils import get_coding_environment
 from quantalogic.utils.get_quantalogic_rules_content import get_quantalogic_rules_file_content
 
 
-def create_coding_agent(model_name: str, vision_model_name: str | None = None, basic: bool = False) -> Agent:
+def create_coding_agent(model_name: str, vision_model_name: str | None = None, basic: bool = False,no_stream: bool = False) -> Agent:
     """Creates and configures a coding agent with a comprehensive set of tools.
 
     Args:
         model_name (str): Name of the language model to use for the agent's core capabilities
         vision_model_name (str | None): Name of the vision model to use for the agent's core capabilities
         basic (bool, optional): If True, the agent will be configured with a basic set of tools.
+        no_stream (bool, optional): If True, the agent will not stream results.
 
     Returns:
         Agent: A fully configured coding agent instance with:
@@ -59,17 +62,19 @@ def create_coding_agent(model_name: str, vision_model_name: str | None = None, b
         ReadFileTool(),
         ExecuteBashCommandTool(),
         InputQuestionTool(),
+        DuckDuckGoSearchTool(),
     ]
 
     if vision_model_name:
-        tools.append(LLMVisionTool(model_name=vision_model_name))
+        tools.append(LLMVisionTool(model_name=vision_model_name, on_token=console_print_token if not no_stream else None))
 
     if not basic:
         tools.append(
             LLMTool(
                 model_name=model_name,
                 system_prompt="You are a software expert, your role is to answer coding questions.",
-                name="coding_consultant",  # Handles implementation-level coding questions                
+                name="coding_consultant",  # Handles implementation-level coding questions
+                on_token=console_print_token if not no_stream else None,
             )
         )
         tools.append(
@@ -77,6 +82,7 @@ def create_coding_agent(model_name: str, vision_model_name: str | None = None, b
                 model_name=model_name,
                 system_prompt="You are a software architect, your role is to answer software architecture questions.",
                 name="software_architect",  # Handles system design and architecture questions
+                on_token=console_print_token if not no_stream else None,
             )
         )
 

quantalogic/{print_event.py → console_print_events.py}

@@ -1,5 +1,3 @@
-"""Print events with rich formatting."""
-
 from typing import Any
 
 from rich import box
@@ -65,4 +63,4 @@ def console_print_events(event: str, data: dict[str, Any] | None = None):
         expand=True,
     )
 
-    console.print(panel)
+    console.print(panel)

quantalogic/console_print_token.py

@@ -0,0 +1,16 @@
+"""Print events with rich formatting."""
+
+from typing import Any
+
+from rich.console import Console
+
+
+def console_print_token(event: str, data: Any | None = None):
+    """Print a token with rich formatting.
+    
+    Args:
+        event (str): The event name (e.g., 'stream_chunk')
+        data (Any | None): The token data to print
+    """
+    console = Console()
+    console.print(data, end="")

quantalogic/docs_cli.py

@@ -0,0 +1,50 @@
+import subprocess
+import os
+import sys
+
+def get_config_path():
+    """Get the absolute path to the mkdocs configuration file."""
+    return os.path.join(os.path.dirname(os.path.dirname(__file__)), 'mkdocs', 'mkdocs.yml')
+
+def serve_docs():
+    """Serve MkDocs documentation locally."""
+    config_path = get_config_path()
+    try:
+        subprocess.run(['mkdocs', 'serve', '--config-file', config_path], check=True)
+    except subprocess.CalledProcessError as e:
+        print(f"Error serving documentation: {e}")
+        sys.exit(1)
+
+def build_docs():
+    """Build MkDocs documentation."""
+    config_path = get_config_path()
+    try:
+        subprocess.run(['mkdocs', 'build', '--config-file', config_path], check=True)
+        print("Documentation built successfully.")
+    except subprocess.CalledProcessError as e:
+        print(f"Error building documentation: {e}")
+        sys.exit(1)
+
+def deploy_docs():
+    """Deploy MkDocs documentation to GitHub Pages."""
+    config_path = get_config_path()
+    try:
+        subprocess.run(['mkdocs', 'gh-deploy', '--config-file', config_path], check=True)
+        print("Documentation deployed successfully.")
+    except subprocess.CalledProcessError as e:
+        print(f"Error deploying documentation: {e}")
+        sys.exit(1)
+
+# Ensure the script can be run directly for testing
+if __name__ == '__main__':
+    command = sys.argv[1] if len(sys.argv) > 1 else None
+    
+    if command == 'serve':
+        serve_docs()
+    elif command == 'build':
+        build_docs()
+    elif command == 'deploy':
+        deploy_docs()
+    else:
+        print("Usage: python docs_cli.py [serve|build|deploy]")
+        sys.exit(1)