quantalogic 0.2.0__py3-none-any.whl

quantalogic/agent_config.py

@@ -0,0 +1,138 @@
+"""Module for agent configuration and creation."""
+
+# Standard library imports
+
+# Local application imports
+from quantalogic.agent import Agent
+from quantalogic.coding_agent import create_coding_agent
+from quantalogic.tools import (
+    AgentTool,
+    DownloadHttpFileTool,
+    EditWholeContentTool,
+    ExecuteBashCommandTool,
+    InputQuestionTool,
+    ListDirectoryTool,
+    LLMTool,
+    MarkitdownTool,
+    NodeJsTool,
+    PythonTool,
+    ReadFileBlockTool,
+    ReadFileTool,
+    ReplaceInFileTool,
+    RipgrepTool,
+    SearchDefinitionNames,
+    TaskCompleteTool,
+    WriteFileTool,
+)
+
+MODEL_NAME = "deepseek/deepseek-chat"
+
+
+def create_agent(model_name) -> Agent:
+    """Create an agent with the specified model and tools.
+
+    Args:
+        model_name (str): Name of the model to use
+    """
+    return Agent(
+        model_name=model_name,
+        tools=[
+            TaskCompleteTool(),
+            ReadFileTool(),
+            ReadFileBlockTool(),
+            WriteFileTool(),
+            EditWholeContentTool(),
+            InputQuestionTool(),
+            ListDirectoryTool(),
+            ExecuteBashCommandTool(),
+            ReplaceInFileTool(),
+            RipgrepTool(),
+            SearchDefinitionNames(),
+            MarkitdownTool(),
+            LLMTool(model_name=model_name),
+            DownloadHttpFileTool(),
+        ],
+    )
+
+
+def create_interpreter_agent(model_name: str) -> Agent:
+    """Create an interpreter agent with the specified model and tools.
+
+    Args:
+        model_name (str): Name of the model to use
+    """
+    return Agent(
+        model_name=model_name,
+        tools=[
+            TaskCompleteTool(),
+            ReadFileTool(),
+            ReadFileBlockTool(),
+            WriteFileTool(),
+            EditWholeContentTool(),
+            InputQuestionTool(),
+            ListDirectoryTool(),
+            ExecuteBashCommandTool(),
+            ReplaceInFileTool(),
+            RipgrepTool(),
+            PythonTool(),
+            NodeJsTool(),
+            SearchDefinitionNames(),
+            DownloadHttpFileTool(),
+        ],
+    )
+
+
+def create_full_agent(model_name: str) -> Agent:
+    """Create an agent with the specified model and many tools.
+
+    Args:
+        model_name (str): Name of the model to use
+    """
+    return Agent(
+        model_name=model_name,
+        tools=[
+            TaskCompleteTool(),
+            ReadFileTool(),
+            ReadFileBlockTool(),
+            WriteFileTool(),
+            EditWholeContentTool(),
+            InputQuestionTool(),
+            ListDirectoryTool(),
+            ExecuteBashCommandTool(),
+            ReplaceInFileTool(),
+            RipgrepTool(),
+            PythonTool(),
+            NodeJsTool(),
+            SearchDefinitionNames(),
+            MarkitdownTool(),
+            LLMTool(model_name=model_name),
+            DownloadHttpFileTool(),
+        ],
+    )
+
+
+def create_orchestrator_agent(model_name: str) -> Agent:
+    """Create an agent with the specified model and tools.
+
+    Args:
+        model_name (str): Name of the model to use
+    """
+    # Rebuild AgentTool to resolve forward references
+    AgentTool.model_rebuild()
+
+    coding_agent_instance = create_coding_agent(model_name)
+
+    return Agent(
+        model_name=model_name,
+        tools=[
+            TaskCompleteTool(),
+            ListDirectoryTool(),
+            ReadFileBlockTool(),
+            RipgrepTool(),
+            SearchDefinitionNames(),
+            LLMTool(model_name=MODEL_NAME),
+            AgentTool(agent=coding_agent_instance, agent_role="software expert", name="coder_agent_tool"),
+        ],
+    )
+
+

quantalogic/coding_agent.py

@@ -0,0 +1,83 @@
+from quantalogic.agent import Agent
+from quantalogic.tools import (
+    EditWholeContentTool,
+    ExecuteBashCommandTool,
+    InputQuestionTool,
+    ListDirectoryTool,
+    LLMTool,
+    ReadFileBlockTool,
+    ReadFileTool,
+    ReplaceInFileTool,
+    RipgrepTool,
+    SearchDefinitionNames,
+    TaskCompleteTool,
+    WriteFileTool,
+)
+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, basic: 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
+        basic (bool, optional): If True, the agent will be configured with a basic set of tools.
+
+    Returns:
+        Agent: A fully configured coding agent instance with:
+            - File manipulation tools
+            - Code search capabilities
+            - Specialized language model tools for coding and architecture
+    """
+    specific_expertise = (
+        "Software expert focused on pragmatic solutions."
+        "Validates codebase pre/post changes."
+        "Employs SearchDefinitionNames for code search; ReplaceInFileTool for updates."
+        "Exercise caution with the surrounding context during search/replace operations."
+        "For refactoring tasks, take the time to develop a comprehensive plan for implementing the proposed changes."
+    )
+    quantalogic_rules_file_content = get_quantalogic_rules_file_content()
+
+    if quantalogic_rules_file_content:
+        specific_expertise += "\n\n" "<coding_rules>\n" f"{quantalogic_rules_file_content}" "\n</coding_rules>\n"
+
+    tools = [
+        # Core file manipulation tools
+        TaskCompleteTool(),  # Marks task completion
+        ReadFileBlockTool(),  # Reads specific file sections
+        WriteFileTool(),  # Creates new files
+        ReplaceInFileTool(),  # Updates file sections
+        EditWholeContentTool(),  # Modifies entire files
+        # Code navigation and search tools
+        ListDirectoryTool(),  # Lists directory contents
+        RipgrepTool(),  # Searches code with regex
+        SearchDefinitionNames(),  # Finds code definitions
+        # Specialized language model tools
+        ReadFileTool(),
+        ExecuteBashCommandTool(),
+        InputQuestionTool(),
+    ]
+
+    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
+            )
+        )
+        tools.append(
+            LLMTool(
+                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
+            )
+        )
+
+    return Agent(
+        model_name=model_name,
+        tools=tools,
+        specific_expertise=specific_expertise,
+        get_environment=get_coding_environment,
+    )

quantalogic/event_emitter.py

@@ -0,0 +1,223 @@
+import threading
+from typing import Any, Callable
+
+
+class EventEmitter:
+    """A thread-safe event emitter class for managing event listeners and emissions."""
+
+    def __init__(self) -> None:
+        """Initialize an empty EventEmitter instance.
+
+        Creates an empty dictionary to store event listeners,
+        where each event can have multiple callable listeners.
+        Also initializes a list for wildcard listeners that listen to all events.
+        """
+        self._listeners: dict[str, list[Callable[..., Any]]] = {}
+        self._wildcard_listeners: list[Callable[..., Any]] = []
+        self._lock = threading.RLock()
+
+    def on(self, event: str | list[str], listener: Callable[..., Any]) -> None:
+        """Register an event listener for one or more events.
+
+        If event is a list, the listener is registered for each event in the list.
+
+        Parameters:
+        - event (str | list[str]): The event name or a list of event names to listen to.
+        - listener (Callable): The function to call when the specified event(s) are emitted.
+        """
+        if isinstance(event, str):
+            events = [event]
+        elif isinstance(event, list):
+            events = event
+        else:
+            raise TypeError("Event must be a string or a list of strings.")
+
+        with self._lock:
+            for evt in events:
+                if evt == "*":
+                    if listener not in self._wildcard_listeners:
+                        self._wildcard_listeners.append(listener)
+                else:
+                    if evt not in self._listeners:
+                        self._listeners[evt] = []
+                    if listener not in self._listeners[evt]:
+                        self._listeners[evt].append(listener)
+
+    def once(self, event: str | list[str], listener: Callable[..., Any]) -> None:
+        """Register a one-time event listener for one or more events.
+
+        The listener is removed after it is invoked the first time the event is emitted.
+
+        Parameters:
+        - event (str | list[str]): The event name or a list of event names to listen to.
+        """
+
+        def wrapper(*args: Any, **kwargs: Any) -> None:
+            self.off(event, wrapper)
+            listener(*args, **kwargs)
+
+        self.on(event, wrapper)
+
+    def off(
+        self,
+        event: str | list[str] | None = None,
+        listener: Callable[..., Any] = None,
+    ) -> None:
+        """Unregister an event listener.
+
+        If event is None, removes the listener from all events.
+
+        Parameters:
+        - event (str | list[str] | None): The name of the event or a list of event names to stop listening to.
+                                           If None, removes the listener from all events.
+        - listener (Callable): The function to remove from the event listeners.
+        """
+        with self._lock:
+            if event is None:
+                # Remove from all specific events
+                for evt_list in self._listeners.values():
+                    if listener in evt_list:
+                        evt_list.remove(listener)
+                # Remove from wildcard listeners
+                if listener in self._wildcard_listeners:
+                    self._wildcard_listeners.remove(listener)
+            else:
+                if isinstance(event, str):
+                    events = [event]
+                elif isinstance(event, list):
+                    events = event
+                else:
+                    raise TypeError("Event must be a string, a list of strings, or None.")
+
+                for evt in events:
+                    if evt == "*":
+                        if listener in self._wildcard_listeners:
+                            self._wildcard_listeners.remove(listener)
+                    elif evt in self._listeners:
+                        try:
+                            self._listeners[evt].remove(listener)
+                        except ValueError:
+                            pass  # Listener was not found for this event
+
+    def emit(self, event: str, *args: Any, **kwargs: Any) -> None:
+        """Emit an event to all registered listeners.
+
+        First, invokes wildcard listeners, then listeners registered to the specific event.
+
+        Parameters:
+        - event (str): The name of the event to emit.
+        - args: Positional arguments to pass to the listeners.
+        - kwargs: Keyword arguments to pass to the listeners.
+        """
+        with self._lock:
+            listeners = list(self._wildcard_listeners)
+            if event in self._listeners:
+                listeners.extend(self._listeners[event])
+
+        for listener in listeners:
+            try:
+                listener(event, *args, **kwargs)
+            except Exception as e:
+                # Log the exception or handle it as needed
+                print(f"Error in listener {listener}: {e}")
+
+    def clear(self, event: str) -> None:
+        """Clear all listeners for a specific event.
+
+        Parameters:
+        - event (str): The name of the event to clear listeners from.
+        """
+        with self._lock:
+            if event in self._listeners:
+                del self._listeners[event]
+
+    def clear_all(self) -> None:
+        """Clear all listeners for all events, including wildcard listeners."""
+        with self._lock:
+            self._listeners.clear()
+            self._wildcard_listeners.clear()
+
+    def listeners(self, event: str) -> list[Callable[..., Any]]:
+        """Retrieve all listeners registered for a specific event, including wildcard listeners.
+
+        Parameters:
+        - event (str): The name of the event.
+
+        Returns:
+        - List of callables registered for the event.
+        """
+        with self._lock:
+            listeners = list(self._wildcard_listeners)
+            if event in self._listeners:
+                listeners.extend(self._listeners[event])
+            return listeners
+
+    def has_listener(self, event: str | None, listener: Callable[..., Any]) -> bool:
+        """Check if a specific listener is registered for an event.
+
+        Parameters:
+        - event (str | None): The name of the event. If None, checks in wildcard listeners.
+        - listener (Callable): The listener to check.
+
+        Returns:
+        - True if the listener is registered for the event, False otherwise.
+        """
+        with self._lock:
+            if event is None:
+                return listener in self._wildcard_listeners
+            elif event == "*":
+                return listener in self._wildcard_listeners
+            else:
+                return listener in self._listeners.get(event, [])
+
+
+if __name__ == "__main__":
+
+    def on_data_received(data):
+        print(f"Data received: {data}")
+
+    def on_any_event(event, data):
+        print(f"Event '{event}' emitted with data: {data}")
+
+    emitter = EventEmitter()
+
+    # Register specific event listener
+    emitter.on("data", on_data_received)
+
+    # Register wildcard listener
+    emitter.on("*", on_any_event)
+
+    # Emit 'data' event
+    emitter.emit("data", "Sample Data")
+
+    # Output:
+    # Event 'data' emitted with data: Sample Data
+    # Data received: Sample Data
+
+    # Emit 'update' event
+    emitter.emit("update", "Update Data")
+
+    # Output:
+    # Event 'update' emitted with data: Update Data
+
+    # Register a one-time listener
+    def once_listener(data):
+        print(f"Once listener received: {data}")
+
+    emitter.once("data", once_listener)
+
+    # Emit 'data' event
+    emitter.emit("data", "First Call")
+
+    # Output:
+    # Event 'data' emitted with data: First Call
+    # Data received: First Call
+    # Once listener received: First Call
+
+    # Emit 'data' event again
+    emitter.emit("data", "Second Call")
+
+    # Output:
+    # Event 'data' emitted with data: Second Call
+    # Data received: Second Call
+    # (Once listener is not called again)

quantalogic/generative_model.py

@@ -0,0 +1,226 @@
+"""Generative model module for AI-powered text generation."""
+
+import openai
+from litellm import completion, exceptions, get_max_tokens, get_model_info, token_counter
+from loguru import logger
+from pydantic import BaseModel, Field, field_validator
+
+MIN_RETRIES = 3
+
+
+class Message(BaseModel):
+    """Represents a message in a conversation with a specific role and content."""
+
+    role: str = Field(..., min_length=1)
+    content: str = Field(..., min_length=1)
+
+    @field_validator("role", "content")
+    @classmethod
+    def validate_not_empty(cls, v: str) -> str:
+        """Validate that the field is not empty or whitespace-only."""
+        if not v or not v.strip():
+            raise ValueError("Field cannot be empty or whitespace-only")
+        return v
+
+
+class TokenUsage(BaseModel):
+    """Represents token usage statistics for a language model."""
+
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+
+
+class ResponseStats(BaseModel):
+    """Represents detailed statistics for a model response."""
+
+    response: str
+    usage: TokenUsage
+    model: str
+    finish_reason: str | None = None
+
+
+class GenerativeModel:
+    """Generative model for AI-powered text generation with configurable parameters."""
+
+    def __init__(
+        self,
+        model: str = "ollama/qwen2.5-coder:14b",
+        temperature: float = 0.7,
+    ) -> None:
+        """Initialize a generative model with configurable parameters.
+
+        Configure the generative model with specified model,
+        temperature, and maximum token settings.
+
+        Args:
+            model: Model identifier.
+                Defaults to "ollama/qwen2.5-coder:14b".
+            temperature: Sampling temperature between 0 and 1.
+                Defaults to 0.7.
+        """
+        self.model = model
+        self.temperature = temperature
+
+    # Define retriable exceptions based on LiteLLM's exception mapping
+    RETRIABLE_EXCEPTIONS = (
+        exceptions.RateLimitError,  # Rate limits - should retry
+        exceptions.APIConnectionError,  # Connection issues - should retry
+        exceptions.ServiceUnavailableError,  # Service issues - should retry
+        exceptions.Timeout,  # Timeout - should retry
+        exceptions.APIError,  # Generic API errors - should retry
+    )
+
+    # Non-retriable exceptions that need specific handling
+    CONTEXT_EXCEPTIONS = (
+        exceptions.ContextWindowExceededError,
+        exceptions.InvalidRequestError,
+    )
+
+    POLICY_EXCEPTIONS = (exceptions.ContentPolicyViolationError,)
+
+    AUTH_EXCEPTIONS = (
+        exceptions.AuthenticationError,
+        exceptions.PermissionDeniedError,
+    )
+
+    # Retry on specific retriable exceptions
+    def generate_with_history(self, messages_history: list[Message], prompt: str) -> ResponseStats:
+        """Generate a response with conversation history.
+
+        Generates a response based on previous conversation messages
+        and a new user prompt.
+
+        Args:
+            messages_history: Previous conversation messages.
+            prompt: Current user prompt.
+
+        Returns:
+            Detailed response statistics.
+
+        Raises:
+            openai.AuthenticationError: If authentication fails.
+            openai.InvalidRequestError: If the request is invalid (e.g., context length exceeded).
+            openai.APIError: For content policy violations or other API errors.
+            Exception: For other unexpected errors.
+        """
+        messages = [{"role": msg.role, "content": str(msg.content)} for msg in messages_history]
+        messages.append({"role": "user", "content": str(prompt)})
+
+        try:
+            logger.debug(f"Generating response for prompt: {prompt}")
+
+            response = completion(
+                temperature=self.temperature,
+                model=self.model,
+                messages=messages,
+                num_retries=MIN_RETRIES,
+            )
+
+            token_usage = TokenUsage(
+                prompt_tokens=response.usage.prompt_tokens,
+                completion_tokens=response.usage.completion_tokens,
+                total_tokens=response.usage.total_tokens,
+            )
+
+            return ResponseStats(
+                response=response.choices[0].message.content,
+                usage=token_usage,
+                model=self.model,
+                finish_reason=response.choices[0].finish_reason,
+            )
+
+        except Exception as e:
+            error_details = {
+                "error_type": type(e).__name__,
+                "message": str(e),
+                "model": self.model,
+                "provider": getattr(e, "llm_provider", "unknown"),
+                "status_code": getattr(e, "status_code", None),
+            }
+
+            logger.error("LLM Generation Error: {}", error_details)
+
+            # Handle authentication and permission errors
+            if isinstance(e, self.AUTH_EXCEPTIONS):
+                raise openai.AuthenticationError(
+                    f"Authentication failed with provider {error_details['provider']}"
+                ) from e
+
+            # Handle context window errors
+            if isinstance(e, self.CONTEXT_EXCEPTIONS):
+                raise openai.InvalidRequestError(f"Context window exceeded or invalid request: {str(e)}") from e
+
+            # Handle content policy violations
+            if isinstance(e, self.POLICY_EXCEPTIONS):
+                raise openai.APIError(f"Content policy violation: {str(e)}") from e
+
+            # For other exceptions, preserve the original error type if it's from OpenAI
+            if isinstance(e, openai.OpenAIError):
+                raise
+
+            # Wrap unknown errors in APIError
+            raise openai.APIError(f"Unexpected error during generation: {str(e)}") from e
+
+    def generate(self, prompt: str) -> ResponseStats:
+        """Generate a response without conversation history.
+
+        Generates a response for a single user prompt without
+        any previous conversation context.
+
+        Args:
+            prompt: User prompt.
+
+        Returns:
+            Detailed response statistics.
+        """
+        return self.generate_with_history([], prompt)
+
+    def get_max_tokens(self) -> int:
+        """Get the maximum number of tokens that can be generated by the model."""
+        return get_max_tokens(self.model)
+
+    def token_counter(self, messages: list[Message]) -> int:
+        """Count the number of tokens in a list of messages."""
+        litellm_messages = [{"role": msg.role, "content": str(msg.content)} for msg in messages]
+        return token_counter(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(self) -> dict | None:
+        """Get information about the model."""
+        model_info = get_model_info(self.model)
+
+        if not model_info:
+            # Search without prefix "openrouter/"
+            model_info = get_model_info(self.model.replace("openrouter/", ""))
+
+        return model_info
+
+    def get_model_max_input_tokens(self) -> int:
+        """Get the maximum number of input tokens for the model."""
+        try:
+            model_info = self.get_model_info()
+            max_tokens = model_info.get("max_input_tokens") if model_info else None
+            return max_tokens
+        except Exception as e:
+            logger.error(f"Error getting max input tokens for {self.model}: {e}")
+            return None
+
+    def get_model_max_output_tokens(self) -> int | None:
+        """Get the maximum number of output tokens for the model."""
+        try:
+            model_info = self.get_model_info()
+            if model_info:
+                return model_info.get("max_output_tokens")
+
+            # Fallback for unmapped models
+            logger.warning(f"No max output tokens found for {self.model}. Using default.")
+            return 4096  # A reasonable default for many chat models
+        except Exception as e:
+            logger.error(f"Error getting max output tokens for {self.model}: {e}")
+            return None