quantalogic 0.30.6__tar.gz → 0.31.0__tar.gz

{quantalogic-0.30.6 → quantalogic-0.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.30.6
+Version: 0.31.0
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com
@@ -14,6 +14,7 @@ Requires-Dist: click (>=8.1.8,<9.0.0)
 Requires-Dist: duckduckgo-search (>=7.2.1,<8.0.0)
 Requires-Dist: faker (>=33.3.1,<34.0.0)
 Requires-Dist: fastapi (>=0.115.6,<0.116.0)
+Requires-Dist: fuzzywuzzy (>=0.18.0,<0.19.0)
 Requires-Dist: google-auth (>=2.20.0,<3.0.0)
 Requires-Dist: google-search-results (>=2.4.2,<3.0.0)
 Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
@@ -35,6 +36,7 @@ Requires-Dist: prompt-toolkit (>=3.0.48,<4.0.0)
 Requires-Dist: pydantic (>=2.10.4,<3.0.0)
 Requires-Dist: pymdown-extensions (>=10.3.1,<11.0.0)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: python-levenshtein (>=0.26.1,<0.27.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Requires-Dist: rich (>=13.9.4,<14.0.0)
 Requires-Dist: serpapi (>=0.1.5,<0.2.0)
@@ -162,6 +164,9 @@ See our [Release Notes](RELEASE_NOTES.MD) for detailed version history and chang
 | openrouter/openai/gpt-4o | OPENROUTER_API_KEY | OpenAI's GPT-4o model accessible through OpenRouter platform. |
 | openrouter/mistralai/mistral-large-2411 | OPENROUTER_API_KEY | Mistral's large model optimized for complex reasoning tasks, available through OpenRouter with enhanced multilingual capabilities. |
 | mistral/mistral-large-2407 | MISTRAL_API_KEY | Mistral's high-performance model designed for enterprise-grade applications, offering advanced reasoning and multilingual support. |
+| dashscope/qwen-max | DASHSCOPE_API_KEY | Alibaba's Qwen-Max model optimized for maximum performance and extensive reasoning capabilities. |
+| dashscope/qwen-plus | DASHSCOPE_API_KEY | Alibaba's Qwen-Plus model offering balanced performance and cost-efficiency for a variety of tasks. |
+| dashscope/qwen-turbo | DASHSCOPE_API_KEY | Alibaba's Qwen-Turbo model designed for fast and efficient responses, ideal for high-throughput scenarios. |
 
 To configure the environment API key for Quantalogic using LiteLLM, set the required environment variable for your chosen provider and any optional variables like `OPENAI_API_BASE` or `OPENROUTER_REFERRER`. Use a `.env` file or a secrets manager to securely store these keys, and load them in your code using `python-dotenv`. For advanced configurations, refer to the [LiteLLM documentation](https://docs.litellm.ai/docs/).
 

{quantalogic-0.30.6 → quantalogic-0.31.0}/README.md

@@ -104,6 +104,9 @@ See our [Release Notes](RELEASE_NOTES.MD) for detailed version history and chang
 | openrouter/openai/gpt-4o | OPENROUTER_API_KEY | OpenAI's GPT-4o model accessible through OpenRouter platform. |
 | openrouter/mistralai/mistral-large-2411 | OPENROUTER_API_KEY | Mistral's large model optimized for complex reasoning tasks, available through OpenRouter with enhanced multilingual capabilities. |
 | mistral/mistral-large-2407 | MISTRAL_API_KEY | Mistral's high-performance model designed for enterprise-grade applications, offering advanced reasoning and multilingual support. |
+| dashscope/qwen-max | DASHSCOPE_API_KEY | Alibaba's Qwen-Max model optimized for maximum performance and extensive reasoning capabilities. |
+| dashscope/qwen-plus | DASHSCOPE_API_KEY | Alibaba's Qwen-Plus model offering balanced performance and cost-efficiency for a variety of tasks. |
+| dashscope/qwen-turbo | DASHSCOPE_API_KEY | Alibaba's Qwen-Turbo model designed for fast and efficient responses, ideal for high-throughput scenarios. |
 
 To configure the environment API key for Quantalogic using LiteLLM, set the required environment variable for your chosen provider and any optional variables like `OPENAI_API_BASE` or `OPENROUTER_REFERRER`. Use a `.env` file or a secrets manager to securely store these keys, and load them in your code using `python-dotenv`. For advanced configurations, refer to the [LiteLLM documentation](https://docs.litellm.ai/docs/).
 

{quantalogic-0.30.6 → quantalogic-0.31.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "quantalogic"
-version = "0.30.6"
+version = "0.31.0"
 description = "QuantaLogic ReAct Agents"
 authors = ["Raphaël MANSUY <raphael.mansuy@gmail.com>"]
 readme = "README.md"
@@ -54,6 +54,8 @@ sqlalchemy = "^2.0.37"
 python-dotenv = "^1.0.1"
 networkx = "^3.4.2"
 faker = "^33.3.1"
+fuzzywuzzy = "^0.18.0"
+python-levenshtein = "^0.26.1"
 
 [tool.poetry.scripts]
 quantalogic = "quantalogic.main:cli"

{quantalogic-0.30.6 → quantalogic-0.31.0}/quantalogic/__init__.py

@@ -1,4 +1,5 @@
-# QuantaLogic package initialization
+"""QuantaLogic package initialization."""
+
 import warnings
 
 # Suppress specific warnings related to Pydantic's V2 configuration changes
@@ -9,13 +10,22 @@ warnings.filterwarnings(
     message=".*config keys have changed in V2:.*|.*'fields' config key is removed in V2.*",
 )
 
-
+# Import public API
+from .llm import generate_completion, generate_image, count_tokens  # noqa: E402
 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 .console_print_events import console_print_events  # noqa: E402
+from .console_print_token import console_print_token  # noqa: E402
 
-"""QuantaLogic package for AI-powered generative models."""
-
-__all__ = ["Agent", "EventEmitter", "AgentMemory", "VariableMemory", "console_print_events","console_print_token"]
+__all__ = [
+    "Agent",
+    "EventEmitter",
+    "AgentMemory",
+    "VariableMemory",
+    "console_print_events",
+    "console_print_token",
+    "generate_completion",
+    "generate_image",
+    "count_tokens"
+]

{quantalogic-0.30.6 → quantalogic-0.31.0}/quantalogic/agent.py

@@ -5,7 +5,7 @@ from datetime import datetime
 from typing import Any
 
 from loguru import logger
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, PrivateAttr
 
 from quantalogic.event_emitter import EventEmitter
 from quantalogic.generative_model import GenerativeModel, ResponseStats, TokenUsage
@@ -52,12 +52,16 @@ class ObserveResponseResult(BaseModel):
 class Agent(BaseModel):
     """Enhanced QuantaLogic agent implementing ReAct framework."""
 
-    model_config = ConfigDict(arbitrary_types_allowed=True, validate_assignment=True, extra="forbid")
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        validate_assignment=True,
+        extra="forbid"
+    )
 
     specific_expertise: str
     model: GenerativeModel
-    memory: AgentMemory = AgentMemory() # A list User / Assistant Messages
-    variable_store: VariableMemory = VariableMemory() # A dictionary of variables (var1: value1, var2: value2)
+    memory: AgentMemory = AgentMemory()  # A list User / Assistant Messages
+    variable_store: VariableMemory = VariableMemory()  # A dictionary of variables
     tools: ToolManager = ToolManager()
     event_emitter: EventEmitter = EventEmitter()
     config: AgentConfig
@@ -71,8 +75,9 @@ class Agent(BaseModel):
     max_output_tokens: int = DEFAULT_MAX_OUTPUT_TOKENS
     max_iterations: int = 30
     system_prompt: str = ""
-    compact_every_n_iterations: int | None = None  # Add this to the class attributes
-    max_tokens_working_memory: int | None = None  # Add max_tokens_working_memory attribute
+    compact_every_n_iterations: int | None = None
+    max_tokens_working_memory: int | None = None
+    _model_name: str = PrivateAttr(default="")
 
     def __init__(
         self,
@@ -84,17 +89,18 @@ class Agent(BaseModel):
         task_to_solve: str = "",
         specific_expertise: str = "General AI assistant with coding and problem-solving capabilities",
         get_environment: Callable[[], str] = get_environment,
-        compact_every_n_iterations: int | None = None,  # if set the memory will be compacted every n iterations
-        max_tokens_working_memory: int | None = None,  # if set the memory will be compacted each time the max_tokens_working_memory is reached
+        compact_every_n_iterations: int | None = None,
+        max_tokens_working_memory: int | None = None,
     ):
         """Initialize the agent with model, memory, tools, and configurations."""
         try:
             logger.debug("Initializing agent...")
-            # Create event emitter first
+            
+            # Create event emitter
             event_emitter = EventEmitter()
 
             # Add TaskCompleteTool to the tools list if not already present
-            if TaskCompleteTool() not in tools:
+            if not any(isinstance(t, TaskCompleteTool) for t in tools):
                 tools.append(TaskCompleteTool())
 
             tool_manager = ToolManager(tools={tool.name: tool for tool in tools})
@@ -114,32 +120,50 @@ class Agent(BaseModel):
                 system_prompt=system_prompt_text,
             )
 
-            logger.debug("Base class init started ...")
+            # Initialize using Pydantic's model_validate
             super().__init__(
+                specific_expertise=specific_expertise,
                 model=GenerativeModel(model=model_name, event_emitter=event_emitter),
                 memory=memory,
                 variable_store=variable_store,
                 tools=tool_manager,
+                event_emitter=event_emitter,
                 config=config,
-                ask_for_user_validation=ask_for_user_validation,
                 task_to_solve=task_to_solve,
-                specific_expertise=specific_expertise,
-                event_emitter=event_emitter,
+                task_to_solve_summary="",
+                ask_for_user_validation=ask_for_user_validation,
+                last_tool_call={},
+                total_tokens=0,
+                current_iteration=0,
+                max_input_tokens=DEFAULT_MAX_INPUT_TOKENS,
+                max_output_tokens=DEFAULT_MAX_OUTPUT_TOKENS,
+                max_iterations=30,
+                system_prompt="",
+                compact_every_n_iterations=compact_every_n_iterations or 30,
+                max_tokens_working_memory=max_tokens_working_memory,
             )
             
-            # Set the new compact_every_n_iterations parameter
-            self.compact_every_n_iterations = compact_every_n_iterations or self.max_iterations
-            logger.debug(f"Memory will be compacted every {self.compact_every_n_iterations} iterations")
+            self._model_name = model_name
             
-            # Set the max_tokens_working_memory parameter
-            self.max_tokens_working_memory = max_tokens_working_memory
+            logger.debug(f"Memory will be compacted every {self.compact_every_n_iterations} iterations")
             logger.debug(f"Max tokens for working memory set to: {self.max_tokens_working_memory}")
-            
             logger.debug("Agent initialized successfully.")
         except Exception as e:
             logger.error(f"Failed to initialize agent: {str(e)}")
             raise
 
+    @property
+    def model_name(self) -> str:
+        """Get the current model name."""
+        return self._model_name
+
+    @model_name.setter
+    def model_name(self, value: str) -> None:
+        """Set the model name."""
+        self._model_name = value
+        # Update the model instance with the new name
+        self.model = GenerativeModel(model=value, event_emitter=self.event_emitter)
+
     def clear_memory(self):
         """Clear the memory and reset the session."""
         self._reset_session(clear_memory=True)
@@ -533,7 +557,10 @@ class Agent(BaseModel):
             question_validation: str = (
                 "Do you permit the execution of this tool?\n"
                 f"Tool: {tool_name}\n"
-                f"Arguments: {arguments_with_values}\n"
+                "Arguments:\n"
+                "<arguments>\n"
+                + "\n".join([f"    <{key}>{value}</{key}>" for key, value in arguments_with_values.items()])
+                + "\n</arguments>\n"
                 "Yes or No"
             )
             permission_granted = self.ask_for_user_validation(question_validation)
@@ -559,20 +586,24 @@ class Agent(BaseModel):
                 key: self._interpolate_variables(value) for key, value in arguments_with_values.items()
             }
             
-            # Convert arguments to correct types
-            try:
-                converted_args = self.tools._convert_kwargs_types(tool_name, **arguments_with_values_interpolated)
-            except ValueError as e:
-                logger.error(f"Type conversion failed: {str(e)}")
-                return "", f"Error: Type conversion failed for tool '{tool_name}': {str(e)}"
+            arguments_with_values_interpolated = arguments_with_values_interpolated
 
             # test if tool need variables in context 
             if tool.need_variables:
                 # Inject variables into the tool if needed
-                converted_args["variables"] = self.variable_store
+                arguments_with_values_interpolated["variables"] = self.variable_store
             if tool.need_caller_context_memory:
                 # Inject caller context into the tool if needed
-                converted_args["caller_context_memory"] = self.memory.memory
+                arguments_with_values_interpolated["caller_context_memory"] = self.memory.memory
+
+            try:
+                # Convert arguments to proper types
+                converted_args = self.tools.validate_and_convert_arguments(
+                    tool_name, 
+                    arguments_with_values_interpolated
+                )
+            except ValueError as e:
+                return "", f"Argument Error: {str(e)}"
 
             # Add injectable variables
             injectable_properties = tool.get_injectable_properties_in_execution()
@@ -599,10 +630,14 @@ class Agent(BaseModel):
         return executed_tool, response
 
     def _interpolate_variables(self, text: str) -> str:
-        """Interpolate variables using $var1$ syntax in the given text."""
+        """Interpolate variables using $var$ syntax in the given text."""
         try:
+            import re
             for var in self.variable_store.keys():
-                text = text.replace(f"${var}$", self.variable_store[var])
+                # Escape the variable name for regex, but use raw value for replacement
+                pattern = rf'\${re.escape(var)}\$'
+                replacement = self.variable_store[var]
+                text = re.sub(pattern, replacement, text)
             return text
         except Exception as e:
             logger.error(f"Error in _interpolate_variables: {str(e)}")
@@ -641,6 +676,7 @@ class Agent(BaseModel):
             "1. Select ONE tool per message\n"
             "2. You will receive the tool's output in the next user response\n"
             "3. Choose the most appropriate tool for each step\n"
+            "4. Use task_complete tool to confirm task completion\n"
         )
         return prompt_use_tools
 
@@ -702,23 +738,32 @@ class Agent(BaseModel):
         return summary.response
 
     def _generate_task_summary(self, content: str) -> str:
-        """Generate a concise summary of the given content using the generative model.
+        """Generate a concise task-focused summary using the generative model.
 
         Args:
             content (str): The content to summarize
 
         Returns:
-            str: Generated summary
+            str: Generated task summary
         """
         try:
             prompt = (
-                "Rewrite this task in a precise, dense, and concise manner:\n"
-                f"{content}\n"
-                "Summary should be 2-3 sentences maximum. No extra comments should be added.\n"
+                "Create an ultra-concise task summary that captures ONLY: \n"
+                "1. Primary objective/purpose\n"
+                "2. Core actions/requirements\n"
+                "3. Desired end-state/outcome\n\n"
+                "Guidelines:\n"
+                "- Use imperative voice\n"
+                "- Exclude background, explanations, and examples\n"
+                "- Compress information using semantic density\n"
+                "- Strict 2-3 sentence maximum (under 50 words)\n"
+                "- Format: 'Concise Task Summary: [Your summary]'\n\n"
+                f"Input Task Description:\n{content}\n\n"
+                "Concise Task Summary:"
             )
             result = self.model.generate(prompt=prompt)
             logger.debug(f"Generated summary: {result.response}")
-            return result.response
+            return result.response.strip() + "\n🚨 The FULL task is in <task> tag in the previous messages.\n"
         except Exception as e:
             logger.error(f"Error generating summary: {str(e)}")
             return f"Summary generation failed: {str(e)}"
@@ -743,3 +788,8 @@ class Agent(BaseModel):
             "session_add_message",
             {"role": "assistant", "content": assistant_content},
         )
+
+    def update_model(self, new_model_name: str) -> None:
+        """Update the model name and recreate the model instance."""
+        self.model_name = new_model_name
+        self.model = GenerativeModel(model=new_model_name, event_emitter=self.event_emitter)

{quantalogic-0.30.6 → quantalogic-0.31.0}/quantalogic/agent_config.py

@@ -37,6 +37,14 @@ load_dotenv()
 MODEL_NAME = "deepseek/deepseek-chat"
 
 
+_current_model_name: str = ""
+
+def get_current_model() -> str:
+    """Retrieve the currently active model name."""
+    if not _current_model_name:
+        raise ValueError("No model initialized")
+    return _current_model_name
+
 def create_agent(
     model_name: str, 
     vision_model_name: str | None, 
@@ -44,6 +52,8 @@ def create_agent(
     compact_every_n_iteration: int | None = None,
     max_tokens_working_memory: int | None = None
 ) -> Agent:
+    global _current_model_name
+    _current_model_name = model_name
     """Create an agent with the specified model and tools.
 
     Args:

{quantalogic-0.30.6 → quantalogic-0.31.0}/quantalogic/agent_factory.py

@@ -1,6 +1,4 @@
-"""Agent factory module for creating different types of agents."""
-
-from typing import Optional
+from typing import Dict, Optional
 
 from loguru import logger
 
@@ -11,7 +9,57 @@ from quantalogic.agent_config import (
     create_interpreter_agent,
 )
 from quantalogic.coding_agent import create_coding_agent
-from quantalogic.search_agent import create_search_agent
+from quantalogic.search_agent import create_search_agent  # noqa: E402
+
+
+class AgentRegistry:
+    """Registry for managing agent instances by name."""
+    
+    _instance = None
+    _agents: Dict[str, Agent] = {}
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @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
+        """
+        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
+        """
+        return cls._agents[name]
+
+    @classmethod
+    def list_agents(cls) -> Dict[str, str]:
+        """List all registered agents.
+        
+        Returns:
+            Dictionary mapping agent names to their types
+        """
+        return {name: type(agent).__name__ for name, agent in cls._agents.items()}
+
+"""Agent factory module for creating different types of agents."""
 
 
 def create_agent_for_mode(
@@ -46,7 +94,7 @@ def create_agent_for_mode(
 
     if mode == "code":
         logger.debug("Creating code agent without basic mode")
-        return create_coding_agent(
+        agent = create_coding_agent(
             model_name,
             vision_model_name,
             basic=False,
@@ -54,8 +102,9 @@ def create_agent_for_mode(
             compact_every_n_iteration=compact_every_n_iteration,
             max_tokens_working_memory=max_tokens_working_memory
         )
+        return agent
     if mode == "code-basic":
-        return create_coding_agent(
+        agent = create_coding_agent(
             model_name,
             vision_model_name,
             basic=True,
@@ -63,44 +112,50 @@ def create_agent_for_mode(
             compact_every_n_iteration=compact_every_n_iteration,
             max_tokens_working_memory=max_tokens_working_memory
         )
+        return agent
     elif mode == "basic":
-        return create_basic_agent(
+        agent = create_basic_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
         )
+        return agent
     elif mode == "full":
-        return create_full_agent(
+        agent = create_full_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
         )
+        return agent
     elif mode == "interpreter":
-        return create_interpreter_agent(
+        agent = create_interpreter_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
         )
+        return agent
     elif mode == "search":
-        return create_search_agent(
+        agent = create_search_agent(
             model_name,
             no_stream=no_stream,
             compact_every_n_iteration=compact_every_n_iteration,
             max_tokens_working_memory=max_tokens_working_memory
         )
+        return agent
     if mode == "search-full":
-        return create_search_agent(
+        agent = create_search_agent(
             model_name,
             mode_full=True,
             no_stream=no_stream,
             compact_every_n_iteration=compact_every_n_iteration,
             max_tokens_working_memory=max_tokens_working_memory
         )
+        return agent
     else:
         raise ValueError(f"Unknown agent mode: {mode}")

quantalogic-0.31.0/quantalogic/config.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class QLConfig:
+    """Central configuration for QuantaLogic agent parameters."""
+    model_name: str
+    verbose: bool
+    mode: str
+    log: str
+    vision_model_name: str | None
+    max_iterations: int
+    compact_every_n_iteration: int | None
+    max_tokens_working_memory: int | None
+    no_stream: bool