quantalogic 0.32.0__py3-none-any.whl → 0.33.1__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,10 +416,19 @@ class Agent(BaseModel):
         """Extract tool usage from the response content."""
         if not content or not isinstance(content, str):
             return {}
-        
+
+        # Extract action 
         xml_parser = ToleranceXMLParser()
+        action = xml_parser.extract_elements(text=content, element_names=["action"])
+
         tool_names = self.tools.tool_names()
-        return xml_parser.extract_elements(text=content, element_names=tool_names)
+
+        if action:
+            return xml_parser.extract_elements(text=action["action"], element_names=tool_names)
+        else:
+            # Fallback to extracting tool usage directly
+            return xml_parser.extract_elements(text=content, element_names=tool_names)
+
 
     def _parse_tool_arguments(self, tool, tool_input: str) -> dict:
         """Parse the tool arguments from the tool input."""
@@ -461,7 +472,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 +505,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,28 +517,46 @@ 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"
+            "## Global Task summary:\n"
+            f"```\n\n{self.task_to_solve_summary}```\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"
+            "## Last executed action result\n"
+            f"Last executed tool {last_exectured_tool} Execution Result:\n"
+            f"\n<{variable_name}>\n{response_display}\n</{variable_name}>\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"
+            "- Use interpolated variables ($variable_name$) where required in tool calls, to minimize token usage, if possible\n"
+            "- strictly follow the required arguments for each tool as defined in system prompt\n"
+            "- Utilize <action><task_complete><answer>...</answer></task_complete><action> to indicate task completion, display the result or if the task is deemed unfeasible."
         )
 
         return formatted_response
@@ -589,10 +620,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 +634,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 +667,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 +760,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

quantalogic/console_print_events.py

@@ -3,64 +3,63 @@ from typing import Any
 from rich import box
 from rich.console import Console
 from rich.panel import Panel
+from rich.text import Text
 from rich.tree import Tree
 
 
 def console_print_events(event: str, data: dict[str, Any] | None = None):
-    """Print events with rich formatting.
-
-    Args:
-        event (str): Name of the event.
-        data (Dict[str, Any], optional): Additional event data. Defaults to None.
-    """
+    """Print events with elegant compact formatting."""
     console = Console()
 
-    # Define panel title with enhanced styling
-    panel_title = f"[bold cyan]Event: {event}[/bold cyan]"
-
+    # Stylish no-data presentation
     if not data:
-        # Display a friendly message when no data is available
         console.print(
-            Panel(
-                "[italic yellow]No additional event data available.[/italic yellow]",
-                title=panel_title,
-                border_style="dim",
-                expand=True,
-                padding=(1, 2),
+            Panel.fit(
+                Text(f"ⓘ No event data", justify="center", style="italic cyan"),
+                title=f"✨ {event}",
+                border_style="cyan",
+                box=box.ROUNDED,
+                padding=(0, 2),
             )
         )
         return
 
-    # Function to render nested dictionaries as a tree
-    def render_tree(data: dict[str, any], tree: Tree):
+    # Enhanced tree rendering with subtle decorations
+    def render_tree(data: dict[str, Any], tree: Tree) -> None:
         for key, value in data.items():
+            key_text = Text(f"◈ {key}", style="bright_magenta")
             if isinstance(value, dict):
-                branch = tree.add(f"[bold magenta]{key}[/bold magenta]")
+                branch = tree.add(key_text)
                 render_tree(value, branch)
             elif isinstance(value, list):
-                branch = tree.add(f"[bold magenta]{key}[/bold magenta]")
-                for index, item in enumerate(value, start=1):
+                branch = tree.add(key_text)
+                for item in value:
                     if isinstance(item, dict):
-                        sub_branch = branch.add(f"[cyan]Item {index}[/cyan]")
+                        sub_branch = branch.add(Text("○", style="cyan"))
                         render_tree(item, sub_branch)
                     else:
-                        branch.add(f"[green]{item}[/green]")
+                        branch.add(Text(f"• {item}", style="dim green"))
             else:
-                tree.add(f"[bold yellow]{key}[/bold yellow]: [white]{value}[/white]")
-
-    # Create a Tree to represent nested data
-    tree = Tree(f"[bold blue]{event} Details[/bold blue]", guide_style="bold bright_blue")
+                tree.add(Text.assemble(
+                    key_text, 
+                    (" → ", "dim"), 
+                    str(value), style="bright_white"
+                ))
 
+    # Create a compact tree with subtle styling
+    tree = Tree("", guide_style="dim cyan", hide_root=True)
     render_tree(data, tree)
 
-    # Create a panel to display the tree
-    panel = Panel(
-        tree,
-        title=panel_title,
-        border_style="bright_blue",
-        padding=(1, 2),
-        box=box.ROUNDED,
-        expand=True,
-    )
-
-    console.print(panel)
+    # Elegant panel design
+    console.print(
+        Panel(
+            tree,
+            title=f"🎯 [bold bright_cyan]{event}[/]",
+            border_style="bright_blue",
+            box=box.DOUBLE_EDGE,
+            padding=(0, 1),
+            subtitle=f"[dim]Items: {len(data)}[/dim]",
+            subtitle_align="right",
+        ),
+        no_wrap=True
+    )

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/llm.py

@@ -60,6 +60,12 @@ PROVIDERS = {
         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"
     )
 }
 

quantalogic/model_info_list.py

@@ -52,6 +52,9 @@ model_info = {
         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/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: short description of the content of each variable.
+    • 📈 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/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/xml_parser.py

@@ -7,7 +7,6 @@ with support for handling malformed XML and CDATA sections.
 import html
 import re
 from collections import defaultdict
-from functools import lru_cache
 from typing import Self
 
 from loguru import logger
@@ -53,29 +52,22 @@ class ToleranceXMLParser:
     """
 
     # Default mappings for element name normalization
-    DEFAULT_NAME_MAP = {
-        "o": "output",
-        "i": "input",
-        "opt": "optional"
-    }
+    DEFAULT_NAME_MAP = {"o": "output", "i": "input", "opt": "optional"}
 
     def __init__(self: Self) -> None:
         """Initialize the parser with regex patterns for matching XML-like elements."""
         # Pattern for matching individual XML elements with better whitespace handling
-        self.element_pattern = re.compile(
-            r"<\s*([^/>]+?)\s*>(.*?)(?:</\s*\1\s*>|<\s*\1\s*>)",
-            re.DOTALL
-        )
+        self.element_pattern = re.compile(r"<\s*([^/>]+?)\s*>(.*?)(?:</\s*\1\s*>|<\s*\1\s*>)", re.DOTALL)
         # Pattern for matching CDATA sections
         self.cdata_pattern = re.compile(r"<!\[CDATA\[(.*?)]]>", re.DOTALL)
         logger.debug("Initialized ToleranceXMLParser with regex patterns")
 
     def _validate_input(self, text: str) -> None:
         """Validate input text before processing.
-        
+
         Args:
             text: Input text to validate.
-            
+
         Raises:
             ValueError: If input text is invalid.
         """
@@ -120,7 +112,6 @@ class ToleranceXMLParser:
         # Only unescape HTML entities, preserve everything else exactly as is
         return html.unescape(content)
 
-    @lru_cache(maxsize=128)
     def _map_element_name(self: Self, name: str) -> str:
         """Map element names to their canonical form.
 
@@ -134,10 +125,10 @@ class ToleranceXMLParser:
 
     def _build_element_pattern(self, element_name: str) -> re.Pattern[str]:
         """Build regex pattern for finding specific XML elements.
-        
+
         Args:
             element_name: Name of the element to match.
-            
+
         Returns:
             Compiled regex pattern for matching the element.
         """
@@ -145,53 +136,45 @@ class ToleranceXMLParser:
         cdata_section = r"(?:<!\[CDATA\[.*?]]>)?"
         content_pattern = f"({non_cdata}{cdata_section}{non_cdata})"
         closing_pattern = "(?:</\1>|<\1>)"
-        
-        return re.compile(
-            f"<{element_name}>{content_pattern}{closing_pattern}",
-            re.DOTALL
-        )
+
+        return re.compile(f"<{element_name}>{content_pattern}{closing_pattern}", re.DOTALL)
 
     def _find_all_elements(self, text: str) -> list[tuple[str, str]]:
         """Find all XML elements in text.
-        
+
         Args:
             text: Input text to search.
-            
+
         Returns:
             List of tuples containing element names and their content.
         """
-        return [(match.group(1), match.group(2) or "") 
-                for match in self.element_pattern.finditer(text)]
+        return [(match.group(1), match.group(2) or "") for match in self.element_pattern.finditer(text)]
 
     def _process_element_content(self, content: str, preserve_cdata: bool) -> str:
         """Process content of a single element.
-        
+
         Args:
             content: Raw element content.
             preserve_cdata: Whether to preserve CDATA sections.
-            
+
         Returns:
             Processed content string.
         """
         content, cdata_sections = self._extract_and_remove_cdata(content, preserve_cdata)
         content = self._clean_content(content)
-        
+
         # If content is empty but we have CDATA sections and we're not preserving them
         if not content.strip() and cdata_sections and not preserve_cdata:
             return cdata_sections[0]
         return content
 
-    def _process_elements(
-        self, 
-        elements: list[tuple[str, str]], 
-        preserve_cdata: bool
-    ) -> dict[str, str]:
+    def _process_elements(self, elements: list[tuple[str, str]], preserve_cdata: bool) -> dict[str, str]:
         """Process found elements and handle CDATA sections.
-        
+
         Args:
             elements: List of element name and content tuples.
             preserve_cdata: Whether to preserve CDATA sections.
-            
+
         Returns:
             Dictionary mapping element names to their processed content.
         """
@@ -199,12 +182,12 @@ class ToleranceXMLParser:
         for name, content in elements:
             name = self._map_element_name(name)
             result[name] = self._process_element_content(content, preserve_cdata)
-            
+
             # Handle nested elements
             nested_elements = self._find_all_elements(content)
             nested_results = self._process_elements(nested_elements, preserve_cdata)
             result.update(nested_results)
-            
+
         return dict(result)
 
     def _extract_element_content(self: Self, text: str, preserve_cdata: bool = False) -> dict[str, str]:
@@ -301,3 +284,22 @@ class ToleranceXMLParser:
             error_msg = error_msg + f"\n{text}\n"
             logger.error(error_msg)
             raise ValueError(error_msg)
+
+
+if __name__ == "__main__":
+    xml_content = """
+<action>
+    <task_complete>
+        <answer>Hello</answer>
+    </task_complete>
+</action>
+"""
+
+    parser = ToleranceXMLParser()
+    parsed_values = parser.extract_elements(xml_content)
+    print(parsed_values)
+    if "action" in parsed_values:
+        print(parsed_values["action"])
+    action = parser.extract_elements(text=xml_content, element_names=["action"])
+    print(action["action"])
+

{quantalogic-0.32.0.dist-info → quantalogic-0.33.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.32.0
+Version: 0.33.1
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com

{quantalogic-0.32.0.dist-info → quantalogic-0.33.1.dist-info}/RECORD

@@ -1,24 +1,24 @@
 quantalogic/__init__.py,sha256=Su8CnOEdqKu4zTytjiP9P5olg-oIDuUA3fMWM1WUdRY,925
-quantalogic/agent.py,sha256=VqxM_VizDpwH3SLAnoSFMjH4a1ijBVOHaI6rXahHP7M,33289
+quantalogic/agent.py,sha256=x-VDSRkC98Rtw-4kvptE68sbtnZo72Y1jDUyaGoXgvs,34835
 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
 quantalogic/config.py,sha256=S_SAdsCoTa1jS8GIJW2TjlCtE5vjGDbMBg-6E0j8K1o,355
-quantalogic/console_print_events.py,sha256=KB-DGi52As8M96eUs1N_vgNqKIFtqv_H8NTOd3TLTgQ,2163
+quantalogic/console_print_events.py,sha256=md1CwNBoi58nW7KRVESna3QfkWDJo8PvugXSKjL-c-k,2129
 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/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=Nk2Dn1lJh1-323Fs7ADfR9ov_eAoJOEEnzyGswZSbJI,5460
+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=bJu2ohQFgZOwmcqydfh5oi5R1G8ZY7jtQlERsR1Z47s,1816
+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=60BzWY31zRS89bIISiIcCLK5764n8Ry-aXFHda4SDq4,3197
 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
@@ -62,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
@@ -90,10 +90,10 @@ quantalogic/utils/read_http_text_content.py,sha256=n3IayT5KcqctIVVF2gOQQAMf3Ow6e
 quantalogic/version.py,sha256=ea_cRutaQk5_lwlLbUUvPFuOT7Of7-gAsDl7wdveS-g,107
 quantalogic/version_check.py,sha256=cttR1lR3OienGLl7NrK1Te1fhDkqSjCci7HC1vFUTSY,1627
 quantalogic/welcome_message.py,sha256=IXMhem8h7srzNUwvw8G_lmEkHU8PFfote021E_BXmVk,3039
-quantalogic/xml_parser.py,sha256=8yDxvKzAEnefNwUAR-wjerMDOj5T5cxak4WPIA83SBw,11516
+quantalogic/xml_parser.py,sha256=iUQZC4a8uqBsP7RAZaY0Ed9k8TCd-ImuF41eF7MR2WM,11615
 quantalogic/xml_tool_parser.py,sha256=Vz4LEgDbelJynD1siLOVkJ3gLlfHsUk65_gCwbYJyGc,3784
-quantalogic-0.32.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-quantalogic-0.32.0.dist-info/METADATA,sha256=w5kJUS98ou0kVeY9fy-WImrW-W9wWZFOXmIQx4xK-_M,23461
-quantalogic-0.32.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-quantalogic-0.32.0.dist-info/entry_points.txt,sha256=h74O_Q3qBRCrDR99qvwB4BpBGzASPUIjCfxHq6Qnups,183
-quantalogic-0.32.0.dist-info/RECORD,,
+quantalogic-0.33.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+quantalogic-0.33.1.dist-info/METADATA,sha256=Y9LVZWkWkL1D0a04gld5M2yJRF1-dEdzTLTaTa3urrM,23461
+quantalogic-0.33.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+quantalogic-0.33.1.dist-info/entry_points.txt,sha256=h74O_Q3qBRCrDR99qvwB4BpBGzASPUIjCfxHq6Qnups,183
+quantalogic-0.33.1.dist-info/RECORD,,