quantalogic 0.30.6__py3-none-any.whl → 0.31.0__py3-none-any.whl

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/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/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/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/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

quantalogic/generative_model.py

@@ -1,24 +1,22 @@
 """Generative model module for AI-powered text generation."""
 
-import functools
 from datetime import datetime
 from typing import Any, Dict, List
 
 import litellm
 import openai
-from litellm import completion, exceptions, get_max_tokens, get_model_info, image_generation, token_counter
+from litellm import exceptions
 from loguru import logger
 from pydantic import BaseModel, Field, field_validator
 
 from quantalogic.event_emitter import EventEmitter  # Importing the EventEmitter class
-from quantalogic.get_model_info import get_max_input_tokens, get_max_output_tokens, model_info
+from quantalogic.get_model_info import get_max_input_tokens, get_max_output_tokens, get_max_tokens
+from quantalogic.llm import count_tokens, generate_completion, generate_image
 
 MIN_RETRIES = 1
 
 
-
-litellm.suppress_debug_info = True # Very important to suppress prints don't remove
-
+litellm.suppress_debug_info = True  # Very important to suppress prints don't remove
 
 
 # Define the Message class for conversation handling
@@ -90,17 +88,16 @@ class GenerativeModel:
 
         Args:
             model: Model identifier. Defaults to "ollama/qwen2.5-coder:14b".
-            temperature: Temperature parameter for controlling randomness in generation. 
-                        Higher values (e.g. 0.8) make output more random, lower values (e.g. 0.2) 
+            temperature: Temperature parameter for controlling randomness in generation.
+                        Higher values (e.g. 0.8) make output more random, lower values (e.g. 0.2)
                         make it more deterministic. Defaults to 0.7.
-            event_emitter: Optional event emitter instance for handling asynchronous events 
+            event_emitter: Optional event emitter instance for handling asynchronous events
                           and callbacks during text generation. Defaults to None.
         """
         logger.debug(f"Initializing GenerativeModel with model={model}, temperature={temperature}")
         self.model = model
         self.temperature = temperature
         self.event_emitter = event_emitter or EventEmitter()  # Initialize event emitter
-        self._get_model_info_cached = functools.lru_cache(maxsize=32)(self._get_model_info_impl)
 
     # Define retriable exceptions based on LiteLLM's exception mapping
     RETRIABLE_EXCEPTIONS = (
@@ -161,7 +158,7 @@ class GenerativeModel:
         try:
             logger.debug(f"Generating response for prompt: {prompt}")
 
-            response = completion(
+            response = generate_completion(
                 temperature=self.temperature,
                 model=self.model,
                 messages=messages,
@@ -187,7 +184,7 @@ class GenerativeModel:
     def _stream_response(self, messages):
         """Private method to handle streaming responses."""
         try:
-            for chunk in completion(
+            for chunk in generate_completion(
                 temperature=self.temperature,
                 model=self.model,
                 messages=messages,
@@ -253,96 +250,21 @@ class GenerativeModel:
         """Count the number of tokens in a list of messages."""
         logger.debug(f"Counting tokens for {len(messages)} messages using model {self.model}")
         litellm_messages = [{"role": msg.role, "content": str(msg.content)} for msg in messages]
-        token_count = token_counter(model=self.model, messages=litellm_messages)
-        logger.debug(f"Token count: {token_count}")
-        return token_count
+        return count_tokens(model=self.model, messages=litellm_messages)
 
     def token_counter_with_history(self, messages_history: list[Message], prompt: str) -> int:
         """Count the number of tokens in a list of messages and a prompt."""
         litellm_messages = [{"role": msg.role, "content": str(msg.content)} for msg in messages_history]
         litellm_messages.append({"role": "user", "content": str(prompt)})
-        return token_counter(model=self.model, messages=litellm_messages)
-
-    def _get_model_info_impl(self, model_name: str) -> dict:
-        """Get information about the model with prefix fallback logic."""
-        original_model = model_name
-        tried_models = [model_name]
-        
-        while True:
-            try:
-                logger.debug(f"Attempting to retrieve model info for: {model_name}")
-                # Try direct lookup from model_info dictionary first
-                if model_name in model_info:
-                    logger.debug(f"Found model info for {model_name} in model_info")
-                    return model_info[model_name]
-                    
-                # Try get_model_info as fallback
-                info = get_model_info(model_name)
-                if info:
-                    logger.debug(f"Found model info for {model_name} via get_model_info")
-                    return info
-            except Exception as e:
-                logger.debug(f"Failed to get model info for {model_name}: {str(e)}")
-                pass
-
-            # Try removing one prefix level
-            parts = model_name.split("/")
-            if len(parts) <= 1:
-                break
-            model_name = "/".join(parts[1:])
-            tried_models.append(model_name)
-
-        error_msg = f"Could not find model info for {original_model} after trying: {' → '.join(tried_models)}"
-        logger.error(error_msg)
-        raise ValueError(error_msg)
-
-    def get_model_info(self, model_name: str = None) -> dict:
-        """Get cached information about the model."""
-        if model_name is None:
-            model_name = self.model
-        return self._get_model_info_cached(model_name)
+        return count_tokens(model=self.model, messages=litellm_messages)
 
     def get_model_max_input_tokens(self) -> int | None:
         """Get the maximum number of input tokens for the model."""
-        try:
-            # First try direct lookup
-            max_tokens = get_max_input_tokens(self.model)
-            if max_tokens is not None:
-                return max_tokens
-            
-            # If not found, try getting from model info
-            model_info = self.get_model_info()
-            if model_info:
-                return model_info.get("max_input_tokens")
-            
-            # If still not found, log warning and return default
-            logger.warning(f"No max input tokens found for {self.model}. Using default.")
-            return 8192  # A reasonable default for many models
-            
-        except Exception as e:
-            logger.error(f"Error getting max input tokens for {self.model}: {e}")
-            return None
+        return get_max_input_tokens(self.model)
 
     def get_model_max_output_tokens(self) -> int | None:
         """Get the maximum number of output tokens for the model."""
-        try:
-            # First try direct lookup
-            max_tokens = get_max_output_tokens(self.model)
-            if max_tokens is not None:
-                return max_tokens
-            
-            # If not found, try getting from model info
-            model_info = self.get_model_info()
-            if model_info:
-                return model_info.get("max_output_tokens")
-            
-            # If still not found, log warning and return default
-            logger.warning(f"No max output tokens found for {self.model}. Using default.")
-            return 4096  # A reasonable default for many models
-            
-        except Exception as e:
-            logger.error(f"Error getting max output tokens for {self.model}: {e}")
-            return None
+        return get_max_output_tokens(self.model)
 
     def generate_image(self, prompt: str, params: Dict[str, Any]) -> ResponseStats:
         """Generate an image using the specified model and parameters.
@@ -366,16 +288,13 @@ class GenerativeModel:
         """
         try:
             logger.debug(f"Generating image with params: {params}")
-            
+
             # Ensure prompt is in params
             generation_params = {**params}
             generation_params["prompt"] = prompt
-            
+
             # Call litellm's image generation function
-            response = image_generation(
-                model=generation_params.pop("model"),
-                **generation_params
-            )
+            response = generate_image(model=generation_params.pop("model"), **generation_params)
 
             # Convert response data to list of dictionaries with string values
             if hasattr(response, "data"):
@@ -407,7 +326,7 @@ class GenerativeModel:
                 usage=TokenUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
                 model=str(params["model"]),
                 data=data,
-                created=created
+                created=created,
             )
 
         except Exception as e: