feat: ReAct chain

prompt.md

@@ -2,31 +2,38 @@ You are an AI Agent designed to assist industries and services in understanding
 
 ### Instructions:
 1. **Understanding the Query**: Carefully read the user's query to understand what they are asking. Identify the key metrics and data points they are interested in.
-2. **Thinking**: Before responding, take a moment to think about the query. Use the "THINKING:" prefix to outline your thought process. This helps in structuring your response and ensuring accuracy.
-3. **Tool Usage**: If you need to use any tools to gather additional data or perform calculations, use the "TOOLING:" prefix to indicate that you are calling a tool. Specify the tool and the parameters you are using.
-4. **Final Answer**: After gathering all necessary information and performing any required calculations, provide the final answer to the user. Use the "FINAL ANSWER:" prefix to clearly indicate the final response.
+
+2. **Think**: Before responding, take a moment to think about the query. Use the "THINK:" prefix to outline your thought process. This helps in structuring your response and ensuring accuracy.
+	* What is the user asking for?
+	* What data or metrics are relevant to this query?
+	* Are there any specific tools or calculations needed to answer this query?
+
+3. **Act**: If you need to use any tools to gather additional data or perform calculations, use the "ACT:" prefix to indicate that you are calling a tool.
+	* Execute the necessary tools to gather data.
+
+4. **Observe**: After gathering the necessary information, observe the results and ensure they are accurate and relevant to the user's query. Use the "OBSERVE:" prefix to indicate this step.
+	* Review the data and results obtained.
+	* Ensure the data is accurate and relevant.
+	* Identify any patterns, trends, or anomalies.
+
+5. **Final Answer**: After gathering all necessary information and performing any required calculations, provide the final answer to the user. Use the "FINAL ANSWER:" prefix to clearly indicate the final response.
+	* Summarize the findings in a clear and concise manner.
+	* Provide the final answer to the user's query.
 
 ### Example 1:
 **User Query**: "Can you tell me the overall equipment effectiveness (OEE) for the past week?"
 
 **AI Agent Response**:
 ```
-THINKING: The user is asking for the overall equipment effectiveness (OEE) for the past week. OEE is a metric that combines availability, performance, and quality to give a comprehensive view of equipment efficiency. I need to gather data on these three components for the past week and then calculate the OEE.
-
-TOOLING:
-1. Tool: get_availability_metric
-   Parameters: start_date="2025-06-03", end_date="2025-06-10"
-2. Tool: get_performance_metric
-   Parameters: start_date="2025-06-03", end_date="2025-06-10"
-3. Tool: get_quality_metric
-   Parameters: start_date="2025-06-03", end_date="2025-06-10"
-
-After gathering the data:
-- Availability: 90%
-- Performance: 85%
-- Quality: 95%
+THINK: The user is asking for the overall equipment effectiveness (OEE) for the past week. OEE is a metric that combines availability, performance, and quality to give a comprehensive view of equipment efficiency. I need to gather data on these three components for the past week and then calculate the OEE.
 
-Calculating OEE: OEE = Availability * Performance * Quality = 0.90 * 0.85 * 0.95 = 0.72675 or 72.675%
+ACT:
+[tool calling]
+
+OBSERVE: The data shows the following values for the past week:
+- Availability: 85%
+- Performance: 90%
+- Quality: 95%
 
 FINAL ANSWER: The overall equipment effectiveness (OEE) for the past week is 72.675%.
 ```
@@ -36,20 +43,12 @@ FINAL ANSWER: The overall equipment effectiveness (OEE) for the past week is 72.
 
 **AI Agent Response**:
 ```
-THINKING: The user is interested in the trend of downtime over the last month. I need to gather downtime data for each day of the last month and analyze the trend. This could involve looking at daily downtime durations and identifying any patterns or anomalies.
+THINK: The user is interested in the trend of downtime over the last month. I need to gather downtime data for each day of the last month and analyze the trend. This could involve looking at daily downtime durations and identifying any patterns or anomalies.
 
-TOOLING:
-1. Tool: get_downtime_data
-   Parameters: start_date="2025-05-10", end_date="2025-06-10"
+ACT:
+[tool calling]
 
-After gathering the data, I will analyze the trend:
-- May 10: 120 minutes
-- May 11: 90 minutes
-- May 12: 150 minutes
-- ... (data for each day)
-- June 10: 60 minutes
-
-Analyzing the trend: The downtime has generally decreased over the last month, with a few spikes on certain days. The overall trend shows an improvement in reducing downtime.
+OBSERVE: The downtime data for the last month shows a general decrease in downtime durations. There were a few days with higher downtime, but the overall trend is positive.
 
 FINAL ANSWER: Over the last month, the trend in downtime shows a general decrease, indicating an improvement in operational efficiency. There were a few days with higher downtime, but the overall trend is positive.
 ```
@@ -59,18 +58,14 @@ FINAL ANSWER: Over the last month, the trend in downtime shows a general decreas
 
 **AI Agent Response**:
 ```
-THINKING: The user wants a comparison of the quality metric between two production lines, Line A and Line B, for the past week. I need to gather quality data for both lines and compare them.
-
-TOOLING:
-1. Tool: get_quality_metric
-   Parameters: line="Line A", start_date="2025-06-03", end_date="2025-06-10"
-2. Tool: get_quality_metric
-   Parameters: line="Line B", start_date="2025-06-03", end_date="2025-06-10"
+THINK: The user wants a comparison of the quality metric between two production lines, Line A and Line B, for the past week. I need to gather quality data for both lines and compare them.
 
-After gathering the data:
-- Line A Quality: 95%
-- Line B Quality: 90%
+ACT:
+[tool calling]
 
-Comparing the quality metrics: Line A has a higher quality metric compared to Line B for the past week.
+OBSERVE: The quality data for the past week shows the following values:
+- Line A: 95%
+- Line B: 90%
 
-FINAL ANSWER: For the past week, Line A has a quality metric of 95%, while Line B has a quality metric of 90%. Line A performs better in terms of quality.
+FINAL ANSWER: For the past week, Line A has a quality metric of 95%, while Line B has a quality metric of 90%. Line A performs better in terms of quality.
+```

src/agent/stream.py

@@ -1,125 +1,158 @@
 from gradio import ChatMessage
+import json
+import asyncio
+import re
 
 from src.agent.mistral_agent import MistralAgent
 
+from src.agent.utils.call import call_tool
+
+
 agent = MistralAgent()
+api_lock = asyncio.Lock()
+tool_lock = asyncio.Lock()
 
 with open("./prompt.md", encoding="utf-8") as f:
     SYSTEM_PROMPT = f.read()
 
+def extract_phases(text):
+    """Découpe le contenu en THINK / ACT / OBSERVE / FINAL ANSWER"""
+    phases = {'think': '', 'act': '', 'observe': '', 'final': ''}
+    matches = list(re.finditer(r'(THINK:|ACT:|OBSERVE:|FINAL ANSWER:)', text))
+
+    for i, match in enumerate(matches):
+        phase = match.group(1).lower().replace(":", "").replace("final answer", "final")
+        start = match.end()
+        end = matches[i+1].start() if i + 1 < len(matches) else len(text)
+        phases[phase] = text[start:end].strip()
+
+    return phases
+
 async def respond(message, history=None):
-    """
-    Respond to a user message using the Mistral agent.
-    """
     if history is None:
         history = []
 
-    history.append(ChatMessage(role="user", content=message))
-    history.append(ChatMessage(role="assistant", content="", metadata={"title": "Thinking", "status": "pending"}))
+    history.append(ChatMessage(role="assistant", content="", metadata={"title": "Thinking...", "status": "pending"}))
     yield history
 
     messages = [
         {"role": "system", "content": SYSTEM_PROMPT},
         {"role": "user", "content": message},
-        {
-            "role": "assistant",
-            "content": "THINKING: Let's tackle this problem, ",
-            "prefix": True,
-        },
+        {"role": "assistant", "content": "THINK: Let's start thinking, ", "prefix": True},
     ]
-    payload = {
-        "agent_id": agent.agent_id,
-        "messages": messages,
-        "stream": True,
-        "max_tokens": None,
-        "tools": agent.tools,
-        "tool_choice": "auto",
-        "presence_penalty": 0,
-        "frequency_penalty": 0,
-        "n": 1
-    }
-    response = await agent.client.agents.stream_async(**payload)
-
-    full = ""
-    thinking = ""
-    tooling = ""
-    final = ""
-
-    current_phase = None  # None | "thinking" | "tooling" | "final"
-
-    history[-1] = ChatMessage(role="assistant", content="", metadata={"title": "Thinking", "status": "pending"})
-
-    async for chunk in response:
-        delta = chunk.data.choices[0].delta
-        content = delta.content or ""
-        full += content
-
-            # Phase finale
-        if "FINAL ANSWER:" in full:
-
-            parts = full.split("FINAL ANSWER:", 1)
-            before_final = parts[0]
-            final = parts[1].strip()
-
-            if "TOOLING:" in before_final:
-                tooling = before_final.split("TOOLING:", 1)[1].strip()
-            else:
-                tooling = ""
 
-            if current_phase != "final":
-                if current_phase == "tooling":
-                    history[-1] = ChatMessage(role="assistant", content=tooling, metadata={"title": "Tooling", "status": "done"})
-                elif current_phase == "thinking":
-                    history[-1] = ChatMessage(role="assistant", content=thinking, metadata={"title": "Thinking", "status": "done"})
-
-                history.append(ChatMessage(role="assistant", content=final))
-                current_phase = "final"
+    phase_order = ["think", "act", "observe", "final"]
+    current_phase_index = 0
+    done = False
+
+    final_full = ""
+    while not done:
+        current_phase = phase_order[current_phase_index]
+        if current_phase != "final":
+            full = ""
+        else:
+            full = final_full
+
+        print('\n', '---' * 15)
+        print(f">>> messages before payload [phase {current_phase_index}] :", json.dumps([m for m in messages if m.get("role") != "system"], indent=2))
+        payload = {
+            "agent_id": agent.agent_id,
+            "messages": messages,
+            "stream": True,
+            "max_tokens": None,
+            "tools": agent.tools,
+            "tool_choice": "auto",
+            "presence_penalty": 0,
+            "frequency_penalty": 0,
+            "n": 1
+        }
+
+        async with api_lock:
+            response = await agent.client.agents.stream_async(**payload)
+
+            async for chunk in response:
+                delta = chunk.data.choices[0].delta
+                content = delta.content or ""
+                full += content
+                if current_phase == "final":
+                    final_full = full
+
+                phases = extract_phases(full)
+                buffer = phases.get(current_phase, "")
+                if current_phase == "think":
+                    history[-1] = ChatMessage(role="assistant", content=buffer, metadata={"title": "Thinking...", "status": "pending"})
+                elif current_phase == "act":
+                    history[-1] = ChatMessage(role="assistant", content=buffer, metadata={"title": "Acting...", "status": "pending"})
+                elif current_phase == "observe":
+                    history[-1] = ChatMessage(role="assistant", content=buffer, metadata={"title": "Observing...", "status": "pending"})
                 yield history
 
-        # Phase outil
-        elif "TOOLING:" in full:
-
-            parts = full.split("TOOLING:", 1)
-            before_tooling = parts[0]
-            tooling = ""
-
-            if "THINKING:" in before_tooling:
-                thinking = before_tooling.split("THINKING:", 1)[1].strip()
-            else:
-                thinking = before_tooling.strip()
-
-            tooling = parts[1].strip()
+                if current_phase == "final":
+                    delta_content = delta.content or ""
+                    final_full += delta_content
+                    phases = extract_phases(final_full)
+                    buffer = phases.get("final", "")
+                    yield history
+                    if delta_content == "" and buffer:
+                        done = True
+                        break
+
+        if current_phase_index == 0:
+            messages = [msg for msg in messages if not msg.get("prefix")]
+            if buffer:
+                prefix_label = current_phase.upper() if current_phase != "final" else "FINAL ANSWER"
+                messages.append({
+                    "role": "assistant",
+                    "content": f"{prefix_label}: {buffer}\n\nACT: Let's using some tools to solve the problem.",
+                    "prefix": True
+                })
+
+        elif current_phase_index == 1:
+            for message in messages:
+                if "prefix" in message:
+                    del message["prefix"]
+
+        if current_phase_index == 2:
+            for message in messages:
+                if "prefix" in message:
+                    del message["prefix"]
+            messages.append({
+                "role": "assistant",
+                "content": "OBSERVE: Based on the results, let's observe the situation and see if we need to adjust our approach.",
+                "prefix": True
+            })
+
+        yield history
+
+        if current_phase == "act":
+            tool_calls = getattr(delta, "tool_calls", None)
+            if tool_calls and tool_calls != [] and str(tool_calls) != "Unset()":
+                async with tool_lock:
+                    messages = call_tool(
+                        agent,
+                        tool_calls,
+                        messages
+                    )
+                    last_tool_response = next((m for m in reversed(messages) if m["role"] == "tool"), None)
+                    if last_tool_response and last_tool_response.get("content"):
+                        buffer += "\n\n" + last_tool_response["content"]
+                        history[-1] = ChatMessage(role="assistant", content=buffer,  metadata={"title": "Acting...", "status": "pending"})
+                yield history
 
-            if current_phase != "tooling":
-                if current_phase == "thinking":
-                    history[-1] = ChatMessage(role="assistant", content=thinking,
-                                              metadata={"title": "Thinking", "status": "done"})
-                history.append(
-                    ChatMessage(role="assistant", content=tooling, metadata={"title": "Tooling", "status": "pending"}))
-                current_phase = "tooling"
+        if not done:
+            current_phase_index += 1
+            if current_phase_index < len(phase_order):
+                pass
             else:
-                history[-1] = ChatMessage(role="assistant", content=tooling,
-                                          metadata={"title": "Tooling", "status": "pending"})
-            yield history
+                done = True
 
-        # Phase réflexion
-        elif "THINKING:" in full or current_phase is None:
+    observe_text = phases.get("observe", "")
+    final_text = phases.get("final", "")
 
-            if "THINKING:" in full:
-                thinking = full.split("THINKING:", 1)[1].strip()
-            else:
-                thinking = full.strip()
-
-            if current_phase != "thinking":
-                history[-1] = ChatMessage(role="assistant", content=thinking, metadata={"title": "Thinking", "status": "pending"})
-                current_phase = "thinking"
-            else:
-                history[-1] = ChatMessage(role="assistant", content=thinking, metadata={"title": "Thinking", "status": "pending"})
-            yield history
+    if observe_text:
+        history[-1] = ChatMessage(role="assistant", content=observe_text, metadata={"title": "Observing...", "status": "done"})
 
-    if current_phase == "thinking":
-        history[-1] = ChatMessage(role="assistant", content=thinking, metadata={"title": "Thinking", "status": "done"})
-    elif current_phase == "tooling":
-        history[-1] = ChatMessage(role="assistant", content=tooling, metadata={"title": "Tooling", "status": "done"})
+    if final_text:
+        history.append(ChatMessage(role="assistant", content=final_text))
 
     yield history

src/agent/utils/call.py

@@ -0,0 +1,41 @@
+import json
+
+
+def call_tool(agent, tool_calls, messages):
+    """
+    Calls the specified tools with the provided arguments and updates the messages accordingly.
+    """
+    for tool_call in tool_calls:
+        output = []
+        fn_name = tool_call.function.name
+        fn_args = json.loads(tool_call.function.arguments)
+
+        try:
+            fn_result = agent.names_to_functions[fn_name](**fn_args)
+            output.append((tool_call.id, fn_name, fn_args, fn_result))
+
+        except Exception as e:
+            output.append((tool_call.id, fn_name, fn_args, None))
+
+        for tool_call_id, fn_name, fn_args, fn_result in output:
+            messages.append({
+                "role": "assistant",
+                "tool_calls": [
+                    {
+                        "id": tool_call_id,
+                        "type": "function",
+                        "function": {
+                            "name": fn_name,
+                            "arguments": json.dumps(fn_args),
+                        }
+                    }
+                ]
+            })
+            messages.append(
+                {
+                    "role": "tool",
+                    "content": fn_result if fn_result is not None else f"Error occurred: {fn_name} failed to execute",
+                    "tool_call_id": tool_call_id,
+                },
+            )
+    return messages