feat: add tooling phase (no call)

prompt.md

@@ -1,62 +1,76 @@
-You are a general AI assistant equipped with various tools to enhance your problem-solving capabilities. Your task is to answer questions by following a structured chain-of-thought process and utilizing appropriate tools when necessary. Adhere to the following guidelines strictly:
+You are an AI Agent designed to assist industries and services in understanding and interpreting their operational metrics. You have access to real-time telemetry data that measures quality, downtime, and operational performance. Your primary goal is to help users comprehend these metrics and make informed decisions based on them.
 
-### Initial Understanding
-Begin by acknowledging the question and briefly restating it in your own words to ensure 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.
 
-### Step-by-Step Reasoning
-Report your thoughts and reasoning process step by step. Each step should logically follow from the previous one. Use the template below for each step in your reasoning process:
+### Example 1:
+**User Query**: "Can you tell me the overall equipment effectiveness (OEE) for the past week?"
 
-#### THOUGHT STEP [X]:
-- **Explanation**: [Provide a detailed explanation of your thought process here.]
-- **Evidence/Assumptions**: [List any evidence, data, or assumptions you are using to support this step.]
-- **Intermediate Conclusion**: [State any intermediate conclusions or insights derived from this step.]
-- **Tool Calling**: [If applicable, mention any tools you plan to use to gather more information or perform specific tasks.]
+**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.
 
-#### TOOL CALLING:
-1. **Tool Identification**: Identify the tool you need to use and the specific function within that tool.
-2. **Tool Execution**: Execute the tool function with the appropriate parameters.
-3. **Result Handling**: Handle the results from the tool execution. If the tool execution fails, note the error and consider alternative approaches.
+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"
 
-#### THOUGHT STEP [X]:
-- **Explanation**: [Provide a detailed explanation of your thought process here, incorporating the results from the tool.]
-- **Evidence/Assumptions**: [List any new evidence, data, or assumptions you are using to support this step.]
-- **Intermediate Conclusion**: [State any new intermediate conclusions or insights derived from this step.]
+After gathering the data:
+- Availability: 90%
+- Performance: 85%
+- Quality: 95%
 
-### Verification
-After presenting your step-by-step reasoning and tool utilization, verify the logical consistency and coherence of your thoughts. Ensure that each step logically leads to the next and that there are no gaps in your reasoning.
-If you find any inconsistencies or gaps, revisit the relevant steps and adjust your reasoning accordingly.
-However, if everything is consistent, summarize your findings and conclusions in the final answer section.
+Calculating OEE: OEE = Availability * Performance * Quality = 0.90 * 0.85 * 0.95 = 0.72675 or 72.675%
 
-### FINAL ANSWER
-Conclude with your final answer, clearly stated and directly addressing the original question. Use the template below for your final answer:
-[Provide a brief summary of your reasoning process and any tools used, then state your final answer clearly and concisely here.]
+FINAL ANSWER: The overall equipment effectiveness (OEE) for the past week is 72.675%.
+```
 
----
+### Example 2:
+**User Query**: "What is the trend in downtime over the last month?"
 
-### Example:
+**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.
 
-**Question**: What is the weather like in Paris today?
+TOOLING:
+1. Tool: get_downtime_data
+   Parameters: start_date="2025-05-10", end_date="2025-06-10"
 
-#### THOUGHT STEP 1:
-- **Explanation**: I need to find out the current weather conditions in Paris.
-- **Evidence/Assumptions**: I assume that the user is asking for real-time weather information.
-- **Intermediate Conclusion**: I need to use a weather API or a reliable weather website to get the latest information.
-- **Tool Calling**: I will use the `get_weather` tool to retrieve the current weather data for Paris.
+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
 
-#### TOOL CALLING:
-1. **Tool Identification**: Identify the `get_weather` tool and the specific function to retrieve weather data.
-2. **Tool Execution**: Execute the `get_weather` function with the parameter set to "Paris".
-3. **Result Handling**: The `get_weather` tool returns the current weather data for Paris.
+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.
 
-#### THOUGHT STEP 2:
-- **Explanation**: I have retrieved the weather data using the `get_weather` tool.
-- **Evidence/Assumptions**: The data provided by the tool is accurate and up-to-date.
-- **Intermediate Conclusion**: The current weather in Paris is sunny with a temperature of 22°C.
+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.
+```
 
-#### Verification:
-- **Explanation**: The steps logically follow from the need to gather real-time data, and the tool used provides accurate information.
-- **Evidence/Assumptions**: The weather data is consistent with typical weather patterns for this time of year in Paris.
-- **Intermediate Conclusion**: The information retrieved is reliable and can be used to answer the user's question.
+### Example 3:
+**User Query**: "How does the quality metric compare between the two production lines, Line A and Line B, for the past week?"
 
-#### FINAL ANSWER:
-Based on the data retrieved from the `get_weather` tool, the current weather in Paris is sunny with a temperature of 22°C.
+**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"
+
+After gathering the data:
+- Line A Quality: 95%
+- Line B Quality: 90%
+
+Comparing the quality metrics: Line A has a higher quality metric compared to Line B for the past week.
+
+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/inference.py

@@ -1,6 +1,4 @@
 import os
-import json
-import time
 from dotenv import load_dotenv
 from mistralai import Mistral
 
@@ -30,166 +28,4 @@ class MistralAgent:
             [
                 calculate_sum,
             ]
-        ).get('tools')
-
-    #def make_initial_request(self, input):
-    #    """Make the initial request to the agent with the given input."""
-    #    with open("./prompt.md", 'r', encoding='utf-8') as file:
-    #        self.prompt = file.read()
-    #    messages = [
-    #        {"role": "system", "content": self.prompt},
-    #        {"role": "user", "content": input},
-    #        {
-    #            "role": "assistant",
-    #            "content": "THINKING:\nLet's tackle this problem, ",
-    #            "prefix": True,
-    #        },
-    #    ]
-    #    payload = {
-    #        "agent_id": self.agent_id,
-    #        "messages": messages,
-    #        "max_tokens": None,
-    #        "stream": True,
-    #        "stop": None,
-    #        "random_seed": None,
-    #        "response_format": None,
-    #        "tools": self.tools,
-    #        "tool_choice": 'auto',
-    #        "presence_penalty": 0,
-    #        "frequency_penalty": 0,
-    #        "n": 1,
-    #        "prediction": None,
-    #        "parallel_tool_calls": None
-    #    }
-    #    stream = self.client.agents.complete(**payload)
-    #    return stream, messages
-#
-    #def run(self, input):
-    #    """Run the agent with the given input and process the response."""
-    #    print("\n===== Asking the agent =====\n")
-    #    stream, messages = self.make_initial_request(input)
-#
-    #    for data in stream:
-    #        # Si `stream` renvoie des chaînes brutes de type `data: {...}`
-    #        if isinstance(data, str) and data.startswith("data: "):
-    #            try:
-    #                json_str = data[len("data: "):].strip()
-    #                if json_str == "[DONE]":
-    #                    break
-    #                chunk = json.loads(json_str)
-    #                delta = chunk.get("choices", [{}])[0].get("delta", {})
-    #                content = delta.get("content")
-    #                if content:
-    #                    yield content
-#
-    #                # Fin de réponse
-    #                if chunk["choices"][0].get("finish_reason") is not None:
-    #                    break
-    #            except json.JSONDecodeError:
-    #                continue
-#
-    #        # Si `stream` donne directement des dicts (selon ton client)
-    #        elif isinstance(data, dict):
-    #            delta = data.get("choices", [{}])[0].get("delta", {})
-    #            content = delta.get("content")
-    #            if content:
-    #                yield content
-#
-    #            if data["choices"][0].get("finish_reason") is not None:
-    #                break
-
-
-
-        #first_iteration = True
-
-        #while True:
-        #    time.sleep(1)
-        #    if hasattr(response, 'choices') and response.choices:
-        #        choice = response.choices[0]
-#
-        #        if first_iteration:
-        #            messages = [message for message in messages if not message.get("prefix")]
-        #            messages.append(
-        #                {
-        #                    "role": "assistant",
-        #                    "content": choice.message.content,
-        #                    "prefix": True,
-        #                },
-        #            )
-        #            first_iteration = False
-        #        else:
-        #            if choice.message.tool_calls:
-        #                results = []
-#
-        #                for tool_call in choice.message.tool_calls:
-        #                    function_name = tool_call.function.name
-        #                    function_params = json.loads(tool_call.function.arguments)
-#
-        #                    try:
-        #                        function_result = self.names_to_functions[function_name](**function_params)
-        #                        results.append((tool_call.id, function_name, function_result))
-#
-        #                    except Exception as e:
-        #                        results.append((tool_call.id, function_name, None))
-#
-        #                for tool_call_id, function_name, function_result in results:
-        #                    messages.append({
-        #                        "role": "assistant",
-        #                        "tool_calls": [
-        #                            {
-        #                                "id": tool_call_id,
-        #                                "type": "function",
-        #                                "function": {
-        #                                    "name": function_name,
-        #                                    "arguments": json.dumps(function_params),
-        #                                }
-        #                            }
-        #                        ]
-        #                    })
-        #                    messages.append(
-        #                        {
-        #                            "role": "tool",
-        #                            "content": function_result if function_result is not None else f"Error occurred: {function_name} failed to execute",
-        #                            "tool_call_id": tool_call_id,
-        #                        },
-        #                    )
-        #                    for message in messages:
-        #                        if "prefix" in message:
-        #                            del message["prefix"]
-        #                    messages.append(
-        #                        {
-        #                            "role": "assistant",
-        #                            "content": f"Based on the results, ",
-        #                            "prefix": True,
-        #                        }
-        #                    )
-        #            else:
-        #                for message in messages:
-        #                    if "prefix" in message:
-        #                        del message["prefix"]
-        #                messages.append(
-        #                    {
-        #                        "role": "assistant",
-        #                        "content": choice.message.content,
-        #                    }
-        #                )
-        #                if 'FINAL ANSWER:' in choice.message.content:
-        #                    print("\n===== END OF REQUEST =====\n", json.dumps(messages, indent=2))
-        #                    ans = choice.message.content.split('FINAL ANSWER:')[1].strip()
-#
-        #                    timestamp = time.strftime("%Y%m%d-%H%M%S")
-        #                    output_file = f"chat_{timestamp}.json"
-        #                    with open(output_file, "w", encoding="utf-8") as f:
-        #                        json.dump(messages, f, indent=2, ensure_ascii=False)
-        #                    print(f"Conversation enregistrée dans {output_file}")
-#
-        #                    return ans
-#
-        #        print("\n===== MESSAGES BEFORE API CALL =====\n", json.dumps(messages, indent=2))
-        #        time.sleep(1)
-        #        response = self.client.agents.complete(
-        #            agent_id=self.agent_id,
-        #            messages=messages,
-        #            tools=self.tools,
-        #            tool_choice='auto',
-        #        )
+        ).get('tools')

src/ui/sidebar.py

@@ -6,31 +6,28 @@ from src.agent.inference import MistralAgent
 
 agent = MistralAgent()
 
-async def respond(message, history=None):
+with open("./prompt.md", encoding="utf-8") as f:
+    SYSTEM_PROMPT = f.read()
 
+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))
 
-    thinking_msg = ChatMessage(
-        role="assistant",
-        content="",
-        metadata={"title": "Thinking", "status": "pending"}
-    )
-    history.append(thinking_msg)
+    history.append(ChatMessage(role="user", content=message))
+    history.append(ChatMessage(role="assistant", content="", metadata={"title": "Thinking", "status": "pending"}))
     yield history
 
-    with open("./prompt.md", encoding="utf-8") as f:
-        prompt = f.read()
-
     messages = [
-        {"role": "system", "content": prompt},
+        {"role": "system", "content": SYSTEM_PROMPT},
         {"role": "user", "content": message},
-        #{
-        #    "role": "assistant",
-        #    "content": "THINKING:\nLet's tackle this problem",
-        ##    "prefix": True
-        #},
+        {
+            "role": "assistant",
+            "content": "THINKING: Let's tackle this problem, ",
+            "prefix": True,
+        },
     ]
     payload = {
         "agent_id": agent.agent_id,
@@ -43,44 +40,93 @@ async def respond(message, history=None):
         "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)
-            thinking = parts[0].replace("THINKING:", "").strip()
+            before_final = parts[0]
             final = parts[1].strip()
-        else:
-            thinking = full.strip()
-            final = ""
-
-        history[-1] = ChatMessage(
-            role="assistant",
-            content=thinking,
-            metadata={"title": "Thinking", "status": "pending"}
-        )
-        yield history
 
-    history[-1] = ChatMessage(
-        role="assistant",
-        content=thinking,
-        metadata={"title": "Thinking", "status": "done"}
-    )
+            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"
+                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 != "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"
+            else:
+                history[-1] = ChatMessage(role="assistant", content=tooling,
+                                          metadata={"title": "Tooling", "status": "pending"})
+            yield history
+
+        # Phase réflexion
+        elif "THINKING:" in full or current_phase is None:
+
+            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 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"})
 
-    history.append(ChatMessage(role="assistant", content=final))
     yield history
 
 
-
 def sidebar_ui(state, width=700, visible=True):
     with gr.Sidebar(width=width, visible=visible):
         gr.Markdown("# Ask Agent")
@@ -118,6 +164,7 @@ def sidebar_ui(state, width=700, visible=True):
                             stop_btn=True,
                             save_history=True,
                             examples=[
+                                ["What is the sum of 1+1 ?"],
                                 ["How is the production process going?"],
                                 ["What are the common issues faced in production?"],
                                # ["What is the status of the current production line?"],