quantalogic 0.31.1__py3-none-any.whl → 0.33.0__py3-none-any.whl

quantalogic/agent.py

@@ -52,11 +52,7 @@ 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
@@ -95,7 +91,7 @@ class Agent(BaseModel):
         """Initialize the agent with model, memory, tools, and configurations."""
         try:
             logger.debug("Initializing agent...")
-            
+
             # Create event emitter
             event_emitter = EventEmitter()
 
@@ -142,9 +138,9 @@ class Agent(BaseModel):
                 compact_every_n_iterations=compact_every_n_iterations or 30,
                 max_tokens_working_memory=max_tokens_working_memory,
             )
-            
+
             self._model_name = model_name
-            
+
             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.")
@@ -168,7 +164,9 @@ class Agent(BaseModel):
         """Clear the memory and reset the session."""
         self._reset_session(clear_memory=True)
 
-    def solve_task(self, task: str, max_iterations: int = 30, streaming: bool = False, clear_memory: bool = True) -> str:
+    def solve_task(
+        self, task: str, max_iterations: int = 30, streaming: bool = False, clear_memory: bool = True
+    ) -> str:
         """Solve the given task using the ReAct framework.
 
         Args:
@@ -182,7 +180,7 @@ class Agent(BaseModel):
             str: The final response after task completion.
         """
         logger.debug(f"Solving task... {task}")
-        self._reset_session(task_to_solve=task, max_iterations=max_iterations,clear_memory=clear_memory)
+        self._reset_session(task_to_solve=task, max_iterations=max_iterations, clear_memory=clear_memory)
 
         # Generate task summary
         self.task_to_solve_summary = self._generate_task_summary(task)
@@ -228,7 +226,9 @@ class Agent(BaseModel):
                     # 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
+                        messages_history=self.memory.memory,
+                        prompt=current_prompt,
+                        streaming=True,
                     ):
                         content += chunk
 
@@ -245,7 +245,8 @@ class Agent(BaseModel):
                     )
                 else:
                     result = self.model.generate_with_history(
-                        messages_history=self.memory.memory, prompt=current_prompt, streaming=False
+                        messages_history=self.memory.memory, prompt=current_prompt, streaming=False,
+                        stop_words=["thinking"]
                     )
 
                 content = result.response
@@ -296,7 +297,7 @@ class Agent(BaseModel):
 
         return answer
 
-    def _reset_session(self, task_to_solve: str = "", max_iterations: int = 30,clear_memory: bool = True):
+    def _reset_session(self, task_to_solve: str = "", max_iterations: int = 30, clear_memory: bool = True):
         """Reset the agent's session."""
         logger.debug("Resetting session...")
         self.task_to_solve = task_to_solve
@@ -316,29 +317,30 @@ class Agent(BaseModel):
     def _compact_memory_if_needed(self, current_prompt: str = ""):
         """Compacts the memory if it exceeds the maximum occupancy or token limit."""
         ratio_occupied = self._calculate_context_occupancy()
-        
+
         # Compact memory if any of these conditions are met:
         # 1. Memory occupancy exceeds MAX_OCCUPANCY, or
         # 2. Current iteration is a multiple of compact_every_n_iterations, or
         # 3. Working memory exceeds max_tokens_working_memory (if set)
         should_compact_by_occupancy = ratio_occupied >= MAX_OCCUPANCY
         should_compact_by_iteration = (
-            self.compact_every_n_iterations is not None and 
-            self.current_iteration > 0 and 
-            self.current_iteration % self.compact_every_n_iterations == 0
+            self.compact_every_n_iterations is not None
+            and self.current_iteration > 0
+            and self.current_iteration % self.compact_every_n_iterations == 0
         )
         should_compact_by_token_limit = (
-            self.max_tokens_working_memory is not None and 
-            self.total_tokens > self.max_tokens_working_memory
+            self.max_tokens_working_memory is not None and self.total_tokens > self.max_tokens_working_memory
         )
-        
+
         if should_compact_by_occupancy or should_compact_by_iteration or should_compact_by_token_limit:
             if should_compact_by_occupancy:
                 logger.debug(f"Memory compaction triggered: Occupancy {ratio_occupied}% exceeds {MAX_OCCUPANCY}%")
-            
+
             if should_compact_by_iteration:
-                logger.debug(f"Memory compaction triggered: Iteration {self.current_iteration} is a multiple of {self.compact_every_n_iterations}")
-            
+                logger.debug(
+                    f"Memory compaction triggered: Iteration {self.current_iteration} is a multiple of {self.compact_every_n_iterations}"
+                )
+
             self._emit_event("memory_full")
             self.memory.compact()
             self.total_tokens = self.model.token_counter_with_history(self.memory.memory, current_prompt)
@@ -399,7 +401,7 @@ class Agent(BaseModel):
                     return self._handle_tool_execution_failure(response)
 
                 variable_name = self.variable_store.add(response)
-                new_prompt = self._format_observation_response(response, variable_name, iteration)
+                new_prompt = self._format_observation_response(response, executed_tool, variable_name, iteration)
 
                 return ObserveResponseResult(
                     next_prompt=new_prompt,
@@ -414,7 +416,7 @@ class Agent(BaseModel):
         """Extract tool usage from the response content."""
         if not content or not isinstance(content, str):
             return {}
-        
+
         xml_parser = ToleranceXMLParser()
         tool_names = self.tools.tool_names()
         return xml_parser.extract_elements(text=content, element_names=tool_names)
@@ -461,7 +463,7 @@ class Agent(BaseModel):
             answer=None,
         )
 
-    def _handle_repeated_tool_call(self, tool_name: str, arguments_with_values: dict) -> (str,str):
+    def _handle_repeated_tool_call(self, tool_name: str, arguments_with_values: dict) -> (str, str):
         """Handle the case where a tool call is repeated."""
         repeat_count = self.last_tool_call.get("count", 0)
         error_message = (
@@ -494,7 +496,9 @@ class Agent(BaseModel):
             answer=None,
         )
 
-    def _format_observation_response(self, response: str, variable_name: str, iteration: int) -> str:
+    def _format_observation_response(
+        self, response: str, last_exectured_tool: str, variable_name: str, iteration: int
+    ) -> str:
         """Format the observation response with the given response, variable name, and iteration."""
         response_display = response
         if len(response) > MAX_RESPONSE_LENGTH:
@@ -504,29 +508,45 @@ class Agent(BaseModel):
             )
 
         # Format the response message
-        formatted_response = (
-            f"Your next step: you Must now plan the next tool call to complete the based on this new observation\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"
-            "Respond only with two XML blocks in markdown as specified in system prompt.\n"
-            "No extra comments must be added.\n"
+        formatted_response = formatted_response = (
+            "# Analysis and Next Action Decision Point\n\n"
+            f"📊 Progress: Iteration {iteration}/{self.max_iterations}\n\n"
+            "## Current Context\n"
+            f"```\n{self.task_to_solve_summary}```\n\n"
+            f"## Latest Tool {last_exectured_tool} Execution Result:\n"
+            f"Variable: ${variable_name}$\n"
+            f"```\n{response_display}```\n\n"
+            "## Available Resources\n"
+            f"🛠️ Tools:\n{self._get_tools_names_prompt()}\n\n"
+            f"📦 Variables:\n{self._get_variable_prompt()}\n\n"
+            "## Your Task\n"
+            "1. Analyze the execution result and progress, formalize if the current step is solved according to the task.\n"
+            "2. Determine the most effective next step\n"
+            "3. Select exactly ONE tool from the available list\n"
+            "4. Utilize variable interpolation where needed\n"
+            "## Response Requirements\n"
+            "Provide TWO markdown-formatted XML blocks:\n"
+            "1. Your analysis of the progression resulting from the execution of the tool in <thinking> tags, don't include <context_analysis/>\n"
+            "2. Your tool execution plan in <tool_name> tags\n\n"
+            "## Response Format\n"
             "```xml\n"
             "<thinking>\n"
-            "...\n"
+            "[Detailed analysis of progress, and reasoning for next step]\n"
             "</thinking>\n"
             "```\n"
             "```xml\n"
-            "< ...tool_name... >\n"
-            "...\n"
-            "</ ...tool_name... >\n"
-            "```"
-        )
+            "<action>\n"
+            "<selected_tool_name>\n"
+            "[Precise instruction for tool execution]\n"
+            "</selected_tool_name>\n"
+            "</action>\n"
+            "```\n\n"
+            "⚠️ Important:\n"
+            "- Respond ONLY with the two XML blocks\n"
+            "- No additional commentary\n"
+            "- If previous step failed, revise approach\n"
+            "- Ensure variable interpolation syntax is correct\n"
+            "- Utilize the <task_complete> tool to indicate task completion, display the result or if the task is deemed unfeasible.")
 
         return formatted_response
 
@@ -589,10 +609,10 @@ class Agent(BaseModel):
             arguments_with_values_interpolated = {
                 key: self._interpolate_variables(value) for key, value in arguments_with_values.items()
             }
-            
+
             arguments_with_values_interpolated = arguments_with_values_interpolated
 
-            # test if tool need variables in context 
+            # test if tool need variables in context
             if tool.need_variables:
                 # Inject variables into the tool if needed
                 arguments_with_values_interpolated["variables"] = self.variable_store
@@ -603,8 +623,7 @@ class Agent(BaseModel):
             try:
                 # Convert arguments to proper types
                 converted_args = self.tools.validate_and_convert_arguments(
-                    tool_name, 
-                    arguments_with_values_interpolated
+                    tool_name, arguments_with_values_interpolated
                 )
             except ValueError as e:
                 return "", f"Argument Error: {str(e)}"
@@ -637,9 +656,10 @@ class Agent(BaseModel):
         """Interpolate variables using $var$ syntax in the given text."""
         try:
             import re
+
             for var in self.variable_store.keys():
                 # Escape the variable name for regex, but use raw value for replacement
-                pattern = rf'\${re.escape(var)}\$'
+                pattern = rf"\${re.escape(var)}\$"
                 replacement = self.variable_store[var]
                 text = re.sub(pattern, replacement, text)
             return text
@@ -729,9 +749,7 @@ class Agent(BaseModel):
         # Remove the last assistant / user message
         user_message = memory_copy.pop()
         assistant_message = memory_copy.pop()
-        summary = self.model.generate_with_history(
-            messages_history=memory_copy, prompt=prompt_summary
-        )
+        summary = self.model.generate_with_history(messages_history=memory_copy, prompt=prompt_summary)
         # Remove user message
         memory_copy.pop()
         # Replace by summary
@@ -751,6 +769,8 @@ class Agent(BaseModel):
             str: Generated task summary
         """
         try:
+            if len(content) < 200:
+                return content
             prompt = (
                 "Create an ultra-concise task summary that captures ONLY: \n"
                 "1. Primary objective/purpose\n"

quantalogic/generative_model.py

@@ -123,7 +123,8 @@ class GenerativeModel:
 
     # Generate a response with conversation history and optional streaming
     def generate_with_history(
-        self, messages_history: list[Message], prompt: str, image_url: str | None = None, streaming: bool = False
+        self, messages_history: list[Message], prompt: str, image_url: str | None = None, streaming: bool = False,
+        stop_words: list[str] | None = None
     ) -> ResponseStats:
         """Generate a response with conversation history and optional image.
 
@@ -132,6 +133,7 @@ class GenerativeModel:
             prompt: Current user prompt.
             image_url: Optional image URL for visual queries.
             streaming: Whether to stream the response.
+            stop_words: Optional list of stop words for streaming
 
         Returns:
             Detailed response statistics or a generator in streaming mode.
@@ -163,6 +165,7 @@ class GenerativeModel:
                 model=self.model,
                 messages=messages,
                 num_retries=MIN_RETRIES,
+                stop=stop_words,
             )
 
             token_usage = TokenUsage(
@@ -181,7 +184,7 @@ class GenerativeModel:
         except Exception as e:
             self._handle_generation_exception(e)
 
-    def _stream_response(self, messages):
+    def _stream_response(self, messages, stop_words: list[str] | None = None):
         """Private method to handle streaming responses."""
         try:
             for chunk in generate_completion(
@@ -189,7 +192,8 @@ class GenerativeModel:
                 model=self.model,
                 messages=messages,
                 num_retries=MIN_RETRIES,
-                stream=True,  # Enable streaming
+                stream=True,  # Enable streaming,
+                stop=stop_words,
             ):
                 if chunk.choices[0].delta.content is not None:
                     self.event_emitter.emit("stream_chunk", chunk.choices[0].delta.content)

quantalogic/get_model_info.py

@@ -1,44 +1,83 @@
-model_info = {
-    "dashscope/qwen-max": {"max_output_tokens": 8 * 1024, "max_input_tokens": 32 * 1024},
-    "dashscope/qwen-plus": {"max_output_tokens": 8 * 1024, "max_input_tokens": 131072},
-    "dashscope/qwen-turbo": {"max_output_tokens": 8 * 1024, "max_input_tokens": 1000000},
-    "deepseek-reasoner": {"max_output_tokens": 8 * 1024, "max_input_tokens": 1024 * 128},
-    "openrouter/deepseek/deepseek-r1": {"max_output_tokens": 8 * 1024, "max_input_tokens": 1024 * 128},
-    "openrouter/mistralai/mistral-large-2411": {"max_output_tokens": 128 * 1024, "max_input_tokens": 1024 * 128},
-    "mistralai/mistral-large-2411": {"max_output_tokens": 128 * 1024, "max_input_tokens": 1024 * 128},
-    "deepseek/deepseek-chat": {"max_output_tokens": 8* 1024, "max_input_tokens": 1024*64},
-    "deepseek/deepseek-reasoner": {"max_output_tokens": 8* 1024, "max_input_tokens": 1024*64, "max_cot_tokens": 1024*32 },
-}
+import loguru
+
+from quantalogic.model_info_list import model_info
+from quantalogic.model_info_litellm import litellm_get_model_max_input_tokens, litellm_get_model_max_output_tokens
+from quantalogic.utils.lm_studio_model_info import ModelInfo, get_model_list
+
+DEFAULT_MAX_OUTPUT_TOKENS = 4 * 1024  # Reasonable default for most models
+DEFAULT_MAX_INPUT_TOKENS = 32 * 1024  # Reasonable default for most models
+
+
+def validate_model_name(model_name: str) -> None:
+    if not isinstance(model_name, str) or not model_name.strip():
+        raise ValueError(f"Invalid model name: {model_name}")
 
 
 def print_model_info():
-    for model, info in model_info.items():
-        print(f"\n{model}:")
-        print(f"  Max Input Tokens: {info['max_input_tokens']:,}")
-        print(f"  Max Output Tokens: {info['max_output_tokens']:,}")
+    for info in model_info.values():
+        print(f"\n{info.model_name}:")
+        print(f"  Max Input Tokens: {info.max_input_tokens:,}")
+        print(f"  Max Output Tokens: {info.max_output_tokens:,}")
 
 
-if __name__ == "__main__":
-    print_model_info()
+def get_max_output_tokens(model_name: str) -> int:
+    """Get max output tokens with safe fallback"""
+    validate_model_name(model_name)
+
+    if model_name.startswith('lm_studio/'):
+        try:
+            models = get_model_list()
+            for model in models.data:
+                if model.id == model_name[len('lm_studio/'):]:
+                    return model.max_context_length
+        except Exception:
+            loguru.logger.warning(f"Could not fetch LM Studio model info for {model_name}, using default")
 
+    if model_name in model_info:
+        return model_info[model_name].max_output_tokens
 
-def get_max_output_tokens(model_name: str) -> int | None:
-    """Get the maximum output tokens for a given model name."""
-    return model_info.get(model_name, {}).get("max_output_tokens", None)
+    try:
+        return litellm_get_model_max_output_tokens(model_name)
+    except Exception as e:
+        loguru.logger.warning(f"Model {model_name} not found in LiteLLM registry, using default")
+        return DEFAULT_MAX_OUTPUT_TOKENS
 
 
-def get_max_input_tokens(model_name: str) -> int | None:
-    """Get the maximum input tokens for a given model name."""
-    return model_info.get(model_name, {}).get("max_input_tokens", None)
+def get_max_input_tokens(model_name: str) -> int:
+    """Get max input tokens with safe fallback"""
+    validate_model_name(model_name)
 
+    if model_name.startswith('lm_studio/'):
+        try:
+            models = get_model_list()
+            for model in models.data:
+                if model.id == model_name[len('lm_studio/'):]:
+                    return model.max_context_length
+        except Exception:
+            loguru.logger.warning(f"Could not fetch LM Studio model info for {model_name}, using default")
 
-def get_max_tokens(model_name: str) -> int | None:
-    """Get the maximum total tokens (input + output) for a given model name."""
-    model_data = model_info.get(model_name, {})
-    max_input = model_data.get("max_input_tokens")
-    max_output = model_data.get("max_output_tokens")
+    if model_name in model_info:
+        return model_info[model_name].max_input_tokens
 
-    if max_input is None or max_output is None:
-        return None
+    try:
+        return litellm_get_model_max_input_tokens(model_name)
+    except Exception:
+        loguru.logger.warning(f"Model {model_name} not found in LiteLLM registry, using default")
+        return DEFAULT_MAX_INPUT_TOKENS
 
-    return max_input + max_output
+
+def get_max_tokens(model_name: str) -> int:
+    """Get total maximum tokens (input + output)"""
+    validate_model_name(model_name)
+
+    # Get input and output tokens separately
+    input_tokens = get_max_input_tokens(model_name)
+    output_tokens = get_max_output_tokens(model_name)
+
+    return input_tokens + output_tokens
+
+
+if __name__ == "__main__":
+    print_model_info()
+    print(get_max_input_tokens("gpt-4o-mini"))
+    print(get_max_output_tokens("openrouter/openai/gpt-4o-mini"))

quantalogic/llm.py

@@ -30,18 +30,56 @@ def get_model_info(model_name: str) -> dict | None:
     return model_info.get(model_name, None)
 
 
+class ModelProviderConfig:
+    def __init__(self, prefix: str, provider: str, base_url: str, env_var: str):
+        self.prefix = prefix
+        self.provider = provider
+        self.base_url = base_url
+        self.env_var = env_var
+
+    def configure(self, model: str, kwargs: Dict[str, Any]) -> None:
+        kwargs["model"] = model.replace(self.prefix, "")
+        kwargs["custom_llm_provider"] = self.provider
+        kwargs["base_url"] = self.base_url
+        api_key = os.getenv(self.env_var)
+        if not api_key:
+            raise ValueError(f"{self.env_var} is not set in the environment variables.")
+        kwargs["api_key"] = api_key
+
+
+# Default provider configurations
+PROVIDERS = {
+    "dashscope": ModelProviderConfig(
+        prefix="dashscope/",
+        provider="openai",
+        base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+        env_var="DASHSCOPE_API_KEY"
+    ),
+    "nvidia": ModelProviderConfig(
+        prefix="nvidia/",
+        provider="openai",
+        base_url="https://integrate.api.nvidia.com/v1",
+        env_var="NVIDIA_API_KEY"
+    ),
+    "ovh": ModelProviderConfig(
+        prefix="ovh/",
+        provider="openai",
+        base_url="https://deepseek-r1-distill-llama-70b.endpoints.kepler.ai.cloud.ovh.net/api/openai_compat/v1",
+        env_var="OVH_API_KEY"
+    )
+}
+
+
 def generate_completion(**kwargs: Dict[str, Any]) -> Any:
     """Wraps litellm completion with proper type hints."""
     model = kwargs.get("model", "")
-    if model.startswith("dashscope/"):
-        # Remove prefix and configure for OpenAI-compatible endpoint
-        kwargs["model"] = model.replace("dashscope/", "")
-        kwargs["custom_llm_provider"] = "openai"  # Explicitly specify OpenAI provider
-        kwargs["base_url"] = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
-        api_key = os.getenv("DASHSCOPE_API_KEY")
-        if not api_key:
-            raise ValueError("DASHSCOPE_API_KEY is not set in the environment variables.")
-        kwargs["api_key"] = api_key
+    
+    # Find matching provider
+    for provider_name, provider_config in PROVIDERS.items():
+        if model.startswith(provider_config.prefix):
+            provider_config.configure(model, kwargs)
+            break
+    
     return completion(**kwargs)
 
 

quantalogic/model_info.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+
+
+class ModelInfo(BaseModel):
+    model_name: str
+    max_input_tokens: int
+    max_output_tokens: int
+    max_cot_tokens: int | None = None
+
+
+class ModelNotFoundError(Exception):
+    """Raised when a model is not found in local registry"""

quantalogic/model_info_list.py

@@ -0,0 +1,60 @@
+from quantalogic.model_info import ModelInfo
+
+model_info = {
+    "dashscope/qwen-max": ModelInfo(
+        model_name="dashscope/qwen-max",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=32 * 1024,
+    ),
+    "dashscope/qwen-plus": ModelInfo(
+        model_name="dashscope/qwen-plus",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=131072,
+    ),
+    "dashscope/qwen-turbo": ModelInfo(
+        model_name="dashscope/qwen-turbo",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=1000000,
+    ),
+    "deepseek-reasoner": ModelInfo(
+        model_name="deepseek-reasoner",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=1024 * 128,
+    ),
+    "openrouter/deepseek/deepseek-r1": ModelInfo(
+        model_name="openrouter/deepseek/deepseek-r1",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=1024 * 128,
+    ),
+    "openrouter/mistralai/mistral-large-2411": ModelInfo(
+        model_name="openrouter/mistralai/mistral-large-2411",
+        max_output_tokens=128 * 1024,
+        max_input_tokens=1024 * 128,
+    ),
+    "mistralai/mistral-large-2411": ModelInfo(
+        model_name="mistralai/mistral-large-2411",
+        max_output_tokens=128 * 1024,
+        max_input_tokens=1024 * 128,
+    ),
+    "deepseek/deepseek-chat": ModelInfo(
+        model_name="deepseek/deepseek-chat",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=1024 * 64,
+    ),
+    "deepseek/deepseek-reasoner": ModelInfo(
+        model_name="deepseek/deepseek-reasoner",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=1024 * 64,
+        max_cot_tokens=1024 * 32,
+    ),
+    "nvidia/deepseek-ai/deepseek-r1": ModelInfo(
+        model_name="nvidia/deepseek-ai/deepseek-r1",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=1024 * 64,
+    ),
+    "ovh/DeepSeek-R1-Distill-Llama-70B": ModelInfo(
+        model_name="ovh/DeepSeek-R1-Distill-Llama-70B",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=1024 * 64,
+    ),
+}

quantalogic/model_info_litellm.py

@@ -0,0 +1,70 @@
+import functools
+
+import litellm
+
+
+@functools.lru_cache(maxsize=32)
+def litellm_get_model_info(model_name: str) -> dict | None:
+    """Get model information with prefix fallback logic using only litellm.
+    
+    Args:
+        model_name: The model identifier to get information for
+        
+    Returns:
+        Dictionary containing model information
+        
+    Raises:
+        ValueError: If model info cannot be found after prefix fallbacks
+    """
+    tried_models = [model_name]
+    
+    while True:
+        try:
+            # Attempt to get model info through litellm
+            info = litellm.get_model_info(model_name)
+            if info:
+                return info
+        except Exception:
+            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)
+
+    return None    
+
+
+def litellm_get_model_max_input_tokens(model_name: str) -> int | None:
+    """Get maximum input tokens for a model using litellm.
+    
+    Args:
+        model_name: The model identifier
+        
+    Returns:
+        Maximum input tokens or None if not found
+    """
+    try:
+        info = litellm_get_model_info(model_name)
+        return info.get("max_input_tokens", 8192)
+    except Exception as e:
+        return 8192  # Default for many modern models
+
+
+def litellm_get_model_max_output_tokens(model_name: str) -> int | None:
+    """Get maximum output tokens for a model using litellm.
+    
+    Args:
+        model_name: The model identifier
+        
+    Returns:
+        Maximum output tokens or None if not found
+    """
+    try:
+        info = litellm_get_model_info(model_name)
+        return info.get("max_output_tokens", 4096)
+    except Exception as e:
+        return 4096  # Conservative default

quantalogic/prompts.py

@@ -1,119 +1,116 @@
+from quantalogic.version import get_version
+
 
 def system_prompt(tools: str, environment: str, expertise: str = ""):
-    """System prompt for the ReAct chatbot."""
+    """System prompt for the ReAct chatbot with enhanced cognitive architecture."""
     return f"""
-### Core Identity
-You are QuantaLogic, an advanced ReAct AI Agent specializing in systematic problem-solving.
+### Agent Identity: QuantaLogic {get_version()}
+Expert ReAct AI Agent implementing OODA (Observe-Orient-Decide-Act) loop with advanced problem-solving capabilities.
 
-### Specific Expertise
+### Domain Expertise
 {expertise}
 
-### Task Format
-Tasks will be presented within XML tags:
-<task>task_description</task>
+### Input Protocol
+Task Format: <task>task_description</task>
+
+### Cognitive Framework
+1. 🔍 OBSERVE: Gather and process information
+2. 🧭 ORIENT: Analyze context and evaluate options
+3. 🎯 DECIDE: Select optimal action path
+4. ⚡ ACT: Execute precise tool operations
 
-### Response Protocol
-Every response must contain exactly two XML blocks:
+### Response Schema [MANDATORY TWO-BLOCK FORMAT]
 
-1. **Analysis Block**:
+1. 🧠 Analysis Block:
 ```xml
 <thinking>
-  <!-- Follow this precise format. Be concise, dense, and use abbreviations, emojis, and Unicode characters to maximize density. -->
-  <task_analysis_if_no_history>
-    <!-- Only include if no conversation history exists: -->
-    * Rewrite the <task> and its context in your own words, ensuring clarity and specificity.
-    * Define detailed criteria for task completion if not already provided.
-    * Identify key components, constraints, and potential challenges.
-    * Break the <task> into smaller, manageable sub-tasks if necessary.
-      - Each sub-task should have a clear objective, specific deliverables, and a logical sequence for progress tracking.
-  </task_analysis_if_no_history>
-  <success_criteria_if_no_history>
-    <!-- Only include if no conversation history exists: -->
-    * Specify measurable outcomes for task completion.
-    * Define explicit quality benchmarks and performance indicators.
-    * Note any constraints or limitations affecting the task.
-  </success_criteria_if_no_history>
-  <strategic_approach_if_no_history>
-    <!-- Only include if no conversation history exists: -->
-    * Outline a high-level strategy for solving the task.
-    * Identify required resources, tools, or information.
-    * Anticipate potential roadblocks and propose contingency plans.
-  </strategic_approach_if_no_history>
-  <last_observation>
-    <!-- Include if conversation history exists: -->
-    <variable>
-      <name>...variable name...</name>
-      <description>...concise description...</description>
-    </variable>
-    <result>
-      ...concise description of the result...
-      How does this result contribute to task progress?
-    </result>
-  </last_observation>
-  <progress_analysis>
-    <!-- Include if conversation history exists: -->
-    * Summarize completed and failed steps concisely.
-    * Identify and evaluate blockers or challenges.
-    * Highlight repetitions and suggest reevaluating the approach if necessary.
-    * Propose potential solutions or alternative strategies.
-  </progress_analysis>
-  <variables>
-    <!-- Include if conversation history exists: -->
-    * List all variable names and their current values concisely.
-  </variables>
-  <next_steps>
-    * Outline immediate actions required.
-    * Justify tool selection and parameter choices.
-    * Use variable interpolation (e.g., `$var1$`) to minimize token generation.
-    * Consider alternatives or reevaluate the plan if previous attempts failed.
-    * Use the `task_complete` tool to confirm task completion.
-  </next_steps>
-  <taskpad>
-    <!-- Optional: Use for notes about intermediate steps. -->
-    <note>...</note>
-  </taskpad>
+  <!-- COGNITIVE PROCESSING MATRIX -->
+
+  <!-- INITIAL TASK ANALYSIS - INCLUDE ONLY IF NO MESSAGE HISTORY EXISTS -->
+  <context_analysis when="no_history">
+    • 📋 Task Decomposition based on task and history: Steps, Dependencies, Constraints
+    • 🎯 Success Metrics: Quantifiable Outcomes
+    • 🛠️ Resource Requirements: Tools, Data, Variables
+    • ⚠️ Risk Assessment: Potential Failures, Mitigations
+  </context_analysis>
+
+  <!-- ALWAYS INCLUDE FOR ONGOING OPERATIONS -->
+  <execution_analysis>
+    <!-- ONGOING OPERATIONS -->
+    • 🔄 Analyze Last Operation Results: Result, Impact, Effectiveness
+    • 📊 Progress Map: Completed%, Remaining%, Blockers
+    • 💾 Variable State: $var: value pairs
+    • 📈 Performance Metrics: Speed, Quality, Resource Usage
+  </execution_analysis>
+
+  <decision_matrix>
+    <!-- ACTION PLANNING -->
+    • 🎯 Next Action: Tool Selection + Rationale
+    • 📥 Input Parameters: Values + Variable Interpolation
+    • 🔄 Fallback Strategy: Alternative Approaches
+    • ✅ Exit Criteria: Completion Conditions
+  </decision_matrix>
+
+  <memory_pad>
+    <!-- OPERATIONAL NOTES -->
+    • 📝 Key Observations
+    • ⚡ Quick Access Data
+  </memory_pad>
 </thinking>
 ```
 
-2. **Action Block**:
+2. ⚡ Action Block:
 ```xml
+<action>
 <tool_name>
-  <!-- Replace `tool_name` with the name of the tool from the available tools. -->
-  <parameter1>
-    <!-- Use variable interpolation (e.g., `$var1$`) to pass context and minimize token generation. -->
-    value1
-  </parameter1>
-  <parameter2>value2</parameter2>
+  <!-- PRECISE TOOL EXECUTION -->
+  <param1>value1</param1> <!-- Use $var$ for variable interpolation -->
+  <param2>value2</param2> <!-- Keep parameters minimal but sufficient -->
 </tool_name>
+</action>
 ```
 
-### Examples of Action Blocks
-- **New Task Example**:
+### Action Patterns
+1. 🆕 New Task:
 ```xml
-<data_analyzer>
-  <file_path>$input_file$</file_path>
-  <operation>validate_structure</operation>
-</data_analyzer>
+<action>
+<analyzer>
+  <input>$data$</input>
+  <mode>initialize</mode>
+</analyzer>
+</action>
 ```
 
-- **Continuing Task Example**:
+2. 🔄 Continuation:
 ```xml
-<memory_optimizer>
-  <process_id>$current_process$</process_id>
-  <target_utilization>75%</target_utilization>
-</memory_optimizer>
+<action>
+<processor>
+  <state>$current$</state>
+  <action>optimize</action>
+</processor>
+</action>
 ```
 
-- **Task Completion Example / When a task is completed**:
+3. ✅ Completion:
 ```xml
+<action>
 <task_complete>
-  <answer>Task completed successfully</answer>
+  <result>$final_output$</result>
 </task_complete>
+</action>
 ```
 
-### Available Tools
-{tools}
+### Operational Parameters
+🛠️ Tools: {tools}
+🌐 Environment: {environment}
 
-### Environment Details
-{environment}
+### Execution Guidelines
+1. 🎯 Maintain laser focus on task objectives
+2. 📊 Use data-driven decision making
+3. 🔄 Implement feedback loops for continuous optimization
+4. ⚡ Maximize efficiency through variable interpolation
+5. 🔍 Monitor and validate each action's impact
+6. 🛑 Fail fast and adapt when encountering blockers
+7. ✅ Verify completion criteria rigorously
 """
+

quantalogic/task_runner.py

@@ -233,6 +233,12 @@ def task_runner(
                 "memory_summary",
             ]
 
+            #def ask_continue(event: str, data: any) -> None:
+            #    ## Ask for ctrl+return
+            #    if event == "task_think_end":
+            #        ## Wait return on the keyboard
+            #        input("Press [Enter] to continue...")
+
             # Add spinner control to event handlers
             def handle_task_think_start(*args, **kwargs):
                 start_spinner(console)
@@ -246,6 +252,11 @@ def task_runner(
                 if data is not None:
                     console.print(data, end="", markup=False)
 
+            #agent.event_emitter.on(
+            #    event="task_think_end",
+            #    listener=ask_continue,
+            #)
+
             agent.event_emitter.on(
                 event=events,
                 listener=console_print_events,

quantalogic/tools/replace_in_file_tool.py

@@ -62,6 +62,7 @@ class ReplaceInFileTool(Tool):
         "Updates sections of content in an existing file using SEARCH/REPLACE blocks. "
         "If exact matches are not found, the tool attempts to find similar sections based on similarity. "
         "Returns the updated content or an error."
+        "⚠️ THIS TOOL MUST BE USED IN PRIORITY TO UPDATE AN EXISTING FILE."
     )
     need_validation: bool = True
 

quantalogic/utils/__init__.py

@@ -5,6 +5,7 @@ from .git_ls import git_ls
 from .get_environment import get_environment
 from .get_coding_environment import get_coding_environment
 from .get_quantalogic_rules_content import get_quantalogic_rules_file_content
+from .lm_studio_model_info import get_model_list
 
 __all__ = [
     "download_http_file",
@@ -14,4 +15,5 @@ __all__ = [
     "get_environment",
     "get_coding_environment",
     "get_quantalogic_rules_file_content",
+    "get_model_list",
 ]

quantalogic/utils/get_all_models.py

@@ -1,8 +1,8 @@
 import litellm
 
-
 from quantalogic.get_model_info import model_info
 
+
 def get_all_models() -> list[str]:
     """
     Retrieves a unified list of all model names supported by LiteLLM and Quantalogic.

quantalogic/utils/lm_studio_model_info.py

@@ -0,0 +1,48 @@
+from enum import Enum
+from typing import List, Literal, Optional
+
+from pydantic import BaseModel, Field
+
+
+class ModelType(str, Enum):
+    LLM = "llm"
+    EMBEDDINGS = "embeddings"
+    VLM = "vlm"
+
+class CompatibilityType(str, Enum):
+    MLX = "mlx"
+    GGUF = "gguf"
+
+class ModelState(str, Enum):
+    LOADED = "loaded"
+    NOT_LOADED = "not-loaded"
+
+class ModelInfo(BaseModel):
+    id: str = Field(..., description="Unique model identifier in LM Studio's namespace")
+    object: Literal["model"] = Field("model", description="Always 'model' for model objects")
+    type: ModelType = Field(..., description="Type of AI model")
+    publisher: str = Field(..., description="Organization or user who published the model")
+    arch: str = Field(..., description="Base architecture family")
+    compatibility_type: CompatibilityType = Field(..., alias="compatibility_type")
+    quantization: Optional[str] = Field(None, description="Quantization method if applicable")
+    state: ModelState = Field(..., description="Current loading state in LM Studio")
+    max_context_length: int = Field(..., alias="max_context_length", ge=0)
+    loaded_context_length: Optional[int] = Field(
+        None, 
+        alias="loaded_context_length",
+        description="Currently allocated context length (only when loaded)",
+        ge=0
+    )
+
+class ModelListResponse(BaseModel):
+    data: List[ModelInfo] = Field(..., description="List of available models")
+    object: Literal["list"] = Field("list", description="Always 'list' for list responses")
+
+def get_model_list() -> ModelListResponse:
+    """Fetch and validate model information from LM Studio's API"""
+    import requests
+    
+    response = requests.get("http://localhost:1234/api/v0/models")
+    response.raise_for_status()
+    
+    return ModelListResponse(**response.json())

{quantalogic-0.31.1.dist-info → quantalogic-0.33.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.31.1
+Version: 0.33.0
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com
@@ -184,12 +184,25 @@ 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. |
+| nvidia/deepseek-ai/deepseek-r1 | NVIDIA_API_KEY | NVIDIA's DeepSeek R1 model optimized for high-performance AI tasks and advanced reasoning capabilities. |
+| lm_studio/mistral-small-24b-instruct-2501 | LM_STUDIO_API_KEY | LM Studio's Mistral Small model optimized for local inference with advanced reasoning capabilities. |
 | 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/).
 
+### LM Studio Local Setup
+
+To use LM Studio with the Mistral model locally, set the following environment variables:
+
+```bash
+export LM_STUDIO_API_BASE="http://localhost:1234/v1"
+export LM_STUDIO_API_KEY="your-api-key-here"
+```
+
+Replace `http://localhost:1234/v1` with your LM Studio server URL and `your-api-key-here` with your actual API key.
+
 
 ## 📦 Installation
 

{quantalogic-0.31.1.dist-info → quantalogic-0.33.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 quantalogic/__init__.py,sha256=Su8CnOEdqKu4zTytjiP9P5olg-oIDuUA3fMWM1WUdRY,925
-quantalogic/agent.py,sha256=5TscD78hIQBaF9pfxIRysC3HjnTJ6e0nyKDwrZMXHak,33223
+quantalogic/agent.py,sha256=3LllyyFILkmm6wz1CmT6942jIgT1oymqiYNzRYO6fAg,34272
 quantalogic/agent_config.py,sha256=SIRVSF0kkrYfvtyHiMCJhnm_nYqJCD2p1pN-reMIy24,7868
 quantalogic/agent_factory.py,sha256=HWKwN_DN57EPmME-hoCD2uJE0DqsPCzGU_V7nq54XzI,5284
 quantalogic/coding_agent.py,sha256=Z7ik6LUvLKDnaW9Ax1iZGC7p1WMnlYEUIlE5lkBP414,4975
@@ -8,14 +8,17 @@ quantalogic/console_print_events.py,sha256=KB-DGi52As8M96eUs1N_vgNqKIFtqv_H8NTOd
 quantalogic/console_print_token.py,sha256=qSU-3kmoZk4T5-1ybrEBi8tIXDPcz7eyWKhGh3E8uIg,395
 quantalogic/docs_cli.py,sha256=3giVbUpespB9ZdTSJ955A3BhcOaBl5Lwsn1AVy9XAeY,1663
 quantalogic/event_emitter.py,sha256=jqot2g4JRXc88K6PW837Oqxbf7shZfO-xdPaUWmzupk,7901
-quantalogic/generative_model.py,sha256=ut_BFy4BqDxNqUXVbM8e_C_CzwNuJkvGWRsbpbKaees,13423
-quantalogic/get_model_info.py,sha256=f64GpkpzeWXKRMBGG9edfAVP1-S-TclmxSaQC91vglw,1976
+quantalogic/generative_model.py,sha256=K0lbtZuuQrI5McPC4pUZ_FdjL32dAy1vM18egmPGaa8,13638
+quantalogic/get_model_info.py,sha256=_9Nb9JQ09HZzT-_gZUSvl4Er7uCXs5ys36sIBa-8DXA,3005
 quantalogic/interactive_text_editor.py,sha256=1vW4poJl7SItRGEeGQgtCFcmRDXmfCM8PE-uBtDBJuE,16658
-quantalogic/llm.py,sha256=yhuC1b5TCXojDXZEJK_PMcWUUxzrpI-gwzlIszAdJMM,4677
+quantalogic/llm.py,sha256=98osu6LmjuYw4g-CDIp1SJkYlfoHNwdvq6yJqI-K5NA,5692
 quantalogic/main.py,sha256=__-4pX2pgoSFvt-aLdp6Qlrq55_SrwP_l8u2uTaQbjg,9262
 quantalogic/memory.py,sha256=zbtRuM05jaS2lJll-92dt5JfYVLERnF_m_9xqp2x-k0,6304
+quantalogic/model_info.py,sha256=j7QqvjEFQDGpDOgQs8uTkVyI3a50Oa_nrsQjyxizTLc,272
+quantalogic/model_info_list.py,sha256=qGDKI5oBbu5oyJSH4o4jGYGqyqYEUMXFRi_qMDAQ2nU,1997
+quantalogic/model_info_litellm.py,sha256=m1Yt4SIiOBRWLx7S8f8k4fcTiKJZKtOvcPN_QvQ_Oxk,1880
 quantalogic/model_names.py,sha256=UZlz25zG9B2dpfwdw_e1Gw5qFsKQ7iME9FJh9Ts4u6s,938
-quantalogic/prompts.py,sha256=M-7rCaQoylnwxedhvy7VmQdgBG6TT1vmcf8_UzPTyY0,4035
+quantalogic/prompts.py,sha256=2DgL979NBXzSfHfBw3KBf7-55wSzIk5vK-uDZbzRQTY,3158
 quantalogic/search_agent.py,sha256=EA_FAPP0dVuUbJ_lAGKfYq1FIJ6oLYzGMgKLMvBL4ZQ,2472
 quantalogic/server/__init__.py,sha256=8sz_PYAUCrkM6JM5EAUeIzNM4NPW6j6UT72JVkc21WQ,91
 quantalogic/server/agent_server.py,sha256=VXaaWqReUSZOCX7CaKS14jria8yZn1kLEc52E2hV7ZA,22510
@@ -26,7 +29,7 @@ quantalogic/server/static/js/event_visualizer.js,sha256=eFkkWyNZw3zOZlF18kxbfsWq
 quantalogic/server/static/js/quantalogic.js,sha256=x7TrlZGR1Y0WLK2DWl1xY847BhEWMPnL0Ua7KtOldUc,22311
 quantalogic/server/templates/index.html,sha256=nDnXJoQEm1vXbhXtgaYk0G5VXj0wwzE6KrqEDhHFpj4,7773
 quantalogic/task_file_reader.py,sha256=AMIJoeVY9Hhu0dBJ-C5EyaOFsXLkhn2oBhVs-WTnnLk,1460
-quantalogic/task_runner.py,sha256=Loa0hr-Bge-kVnTpoGuV7RotFdiAKQL_zj4OB4S6gko,9643
+quantalogic/task_runner.py,sha256=6kL7o0br2YU8FNKyq-rKJo1oGKZKl73vtATpHusPIWQ,10038
 quantalogic/tool_manager.py,sha256=Uh-ufrJPufHqDUrFwKlXw3MOsVGc_4lQxuc6cRvZ7wU,7186
 quantalogic/tools/__init__.py,sha256=pTirT5UBynuTkAzFYebu7ttGAMP3_A0idFvDp6lGZJQ,2146
 quantalogic/tools/agent_tool.py,sha256=MXCXxWHRch7VK4UWhtRP1jeI8Np9Ne2CUGo8vm1oZiM,3064
@@ -59,7 +62,7 @@ quantalogic/tools/python_tool.py,sha256=70HLbfU2clOBgj4axDOtIKzXwEBMNGEAX1nGSf-K
 quantalogic/tools/read_file_block_tool.py,sha256=FTcDAUOOPQOvWRjnRI6nMI1Upus90klR4PC0pbPP_S8,5266
 quantalogic/tools/read_file_tool.py,sha256=l6k-SOIV9krpXAmUTkxzua51S-KHgzGqkcDlD5AD8K0,2710
 quantalogic/tools/read_html_tool.py,sha256=Vq2rHY8a36z1-4rN6c_kYjPUTQ4I2UT154PMpaoWSkA,11139
-quantalogic/tools/replace_in_file_tool.py,sha256=wC7OlV8UpR5JGCD3VGUWlBEE6fMdGEDRcwE22cDSG2E,13764
+quantalogic/tools/replace_in_file_tool.py,sha256=95GqcOC0sZzbWHWzYDVwq7rEwChlOgKxb5cxKk-Y7W8,13844
 quantalogic/tools/ripgrep_tool.py,sha256=sRzHaWac9fa0cCGhECJN04jw_Ko0O3u45KDWzMIYcvY,14291
 quantalogic/tools/search_definition_names.py,sha256=ui0304UgUke6Ca-H3-S4JP9TsdHhRCR5uk9kPuobIDA,18769
 quantalogic/tools/serpapi_search_tool.py,sha256=sX-Noch77kGP2XiwislPNFyy3_4TH6TwMK6C81L3q9Y,5316
@@ -72,15 +75,16 @@ quantalogic/tools/utils/create_sample_database.py,sha256=Aus9xRLGfQfsYnxsAkJ5CW-
 quantalogic/tools/utils/generate_database_report.py,sha256=0D-5fWOfpAh1jEcld5OTQP5x6XkJE5jpNY6FyHv1L2s,10345
 quantalogic/tools/wikipedia_search_tool.py,sha256=bdZ_0dYTxpEfU04tBFsatnLM5P9Z3kAZgKQEjsopJLA,5405
 quantalogic/tools/write_file_tool.py,sha256=_mx9_Zjg2oMAAVzlcHEKjZVZUxQVgbRfcoMKgWnoZcg,3764
-quantalogic/utils/__init__.py,sha256=Ltq7tzLuHCl9BpCvfRVA9Sjrtp1RJesrn7G980lbl_c,563
+quantalogic/utils/__init__.py,sha256=E442CJQuTohKzgI0Wrd4NZEpKascFjz6F4Vy8Y1c_0Y,634
 quantalogic/utils/ask_user_validation.py,sha256=F0jkbFJVXAImcSSP7op6dov5i80hRvZGRvBHbfcZrxg,340
 quantalogic/utils/check_version.py,sha256=grxTfJE85GMue1OAk8z8_q8tjEJxQ8RO6fN3fJ_qedg,1136
 quantalogic/utils/download_http_file.py,sha256=FTN3brq9WvCFvuBX-lYAhjsdYTzQT4m9m2vqlcyjkNk,3472
-quantalogic/utils/get_all_models.py,sha256=GGhonVHUS7MeS6eogmkEwZETSVgeGU9pWCLTzR0XxAU,544
+quantalogic/utils/get_all_models.py,sha256=Ol4e60MwZiJhu8HZ2i_RpIumLmFYYrncB1X9q1KEQh0,544
 quantalogic/utils/get_coding_environment.py,sha256=oMK5ZanOqX_SFaJxUZQGlsAAaiLUgJufCJYDrHnHPuQ,584
 quantalogic/utils/get_environment.py,sha256=7wWruSHYTUlnQWW27qU3WFYZnncqqqdofsxAsUU7lhw,875
 quantalogic/utils/get_quantalogic_rules_content.py,sha256=fnEFTyClXzpI0MLaM-gB9R6l4CJlu2NnaYiR09ciJC8,673
 quantalogic/utils/git_ls.py,sha256=_k6QIQtc0aM1bsG340jBp4VrdevbcH8Pg2CV4r9oHok,5264
+quantalogic/utils/lm_studio_model_info.py,sha256=1eDvZ-I9W8AZbCch1l5rdiSpUxL7qMnfZItdFZkmAWs,1819
 quantalogic/utils/read_file.py,sha256=tSRVHk8dIP4nNLL89v5kRki4hOTjVyjbmuEb2zwvwCY,2077
 quantalogic/utils/read_http_text_content.py,sha256=n3IayT5KcqctIVVF2gOQQAMf3Ow6eenlVgfXTpLcQbw,4410
 quantalogic/version.py,sha256=ea_cRutaQk5_lwlLbUUvPFuOT7Of7-gAsDl7wdveS-g,107
@@ -88,8 +92,8 @@ quantalogic/version_check.py,sha256=cttR1lR3OienGLl7NrK1Te1fhDkqSjCci7HC1vFUTSY,
 quantalogic/welcome_message.py,sha256=IXMhem8h7srzNUwvw8G_lmEkHU8PFfote021E_BXmVk,3039
 quantalogic/xml_parser.py,sha256=8yDxvKzAEnefNwUAR-wjerMDOj5T5cxak4WPIA83SBw,11516
 quantalogic/xml_tool_parser.py,sha256=Vz4LEgDbelJynD1siLOVkJ3gLlfHsUk65_gCwbYJyGc,3784
-quantalogic-0.31.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-quantalogic-0.31.1.dist-info/METADATA,sha256=pLu3KI4tGKodQWubeVQm1G2P7tC9yZp22ZpOl35N074,22789
-quantalogic-0.31.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-quantalogic-0.31.1.dist-info/entry_points.txt,sha256=h74O_Q3qBRCrDR99qvwB4BpBGzASPUIjCfxHq6Qnups,183
-quantalogic-0.31.1.dist-info/RECORD,,
+quantalogic-0.33.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+quantalogic-0.33.0.dist-info/METADATA,sha256=ZPa-Y4-EhqTp_3ixcWa0hLI_grOtN8v5SnoWoZP9to0,23461
+quantalogic-0.33.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+quantalogic-0.33.0.dist-info/entry_points.txt,sha256=h74O_Q3qBRCrDR99qvwB4BpBGzASPUIjCfxHq6Qnups,183
+quantalogic-0.33.0.dist-info/RECORD,,