quantalogic 0.32.0__tar.gz → 0.33.0__tar.gz

{quantalogic-0.32.0 → quantalogic-0.33.0}/PKG-INFO

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

{quantalogic-0.32.0 → quantalogic-0.33.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "quantalogic"
-version = "0.32.0"
+version = "0.33.0"
 description = "QuantaLogic ReAct Agents"
 authors = ["Raphaël MANSUY <raphael.mansuy@gmail.com>"]
 readme = "README.md"

{quantalogic-0.32.0 → quantalogic-0.33.0}/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

{quantalogic-0.32.0 → quantalogic-0.33.0}/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-0.32.0 → quantalogic-0.33.0}/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-0.32.0 → quantalogic-0.33.0}/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-0.33.0/quantalogic/prompts.py

@@ -0,0 +1,116 @@
+from quantalogic.version import get_version
+
+
+def system_prompt(tools: str, environment: str, expertise: str = ""):
+    """System prompt for the ReAct chatbot with enhanced cognitive architecture."""
+    return f"""
+### Agent Identity: QuantaLogic {get_version()}
+Expert ReAct AI Agent implementing OODA (Observe-Orient-Decide-Act) loop with advanced problem-solving capabilities.
+
+### Domain Expertise
+{expertise}
+
+### 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 Schema [MANDATORY TWO-BLOCK FORMAT]
+
+1. 🧠 Analysis Block:
+```xml
+<thinking>
+  <!-- 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:
+```xml
+<action>
+<tool_name>
+  <!-- PRECISE TOOL EXECUTION -->
+  <param1>value1</param1> <!-- Use $var$ for variable interpolation -->
+  <param2>value2</param2> <!-- Keep parameters minimal but sufficient -->
+</tool_name>
+</action>
+```
+
+### Action Patterns
+1. 🆕 New Task:
+```xml
+<action>
+<analyzer>
+  <input>$data$</input>
+  <mode>initialize</mode>
+</analyzer>
+</action>
+```
+
+2. 🔄 Continuation:
+```xml
+<action>
+<processor>
+  <state>$current$</state>
+  <action>optimize</action>
+</processor>
+</action>
+```
+
+3. ✅ Completion:
+```xml
+<action>
+<task_complete>
+  <result>$final_output$</result>
+</task_complete>
+</action>
+```
+
+### Operational Parameters
+🛠️ Tools: {tools}
+🌐 Environment: {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-0.32.0 → quantalogic-0.33.0}/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-0.32.0/quantalogic/prompts.py

@@ -1,119 +0,0 @@
-
-def system_prompt(tools: str, environment: str, expertise: str = ""):
-    """System prompt for the ReAct chatbot."""
-    return f"""
-### Core Identity
-You are QuantaLogic, an advanced ReAct AI Agent specializing in systematic problem-solving.
-
-### Specific Expertise
-{expertise}
-
-### Task Format
-Tasks will be presented within XML tags:
-<task>task_description</task>
-
-### Response Protocol
-Every response must contain exactly two XML blocks:
-
-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>
-</thinking>
-```
-
-2. **Action Block**:
-```xml
-<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>
-</tool_name>
-```
-
-### Examples of Action Blocks
-- **New Task Example**:
-```xml
-<data_analyzer>
-  <file_path>$input_file$</file_path>
-  <operation>validate_structure</operation>
-</data_analyzer>
-```
-
-- **Continuing Task Example**:
-```xml
-<memory_optimizer>
-  <process_id>$current_process$</process_id>
-  <target_utilization>75%</target_utilization>
-</memory_optimizer>
-```
-
-- **Task Completion Example / When a task is completed**:
-```xml
-<task_complete>
-  <answer>Task completed successfully</answer>
-</task_complete>
-```
-
-### Available Tools
-{tools}
-
-### Environment Details
-{environment}
-"""