fix on prophet forecast tool

Author: phenobarbital

parrot/handlers/chat_interaction.py

@@ -277,3 +277,61 @@ async def delete(self) -> web.Response:
             response={"message": f"Conversation {session_id} not found"},
             status=404,
         )
+
+    async def patch(self) -> web.Response:
+        """Delete a specific turn from a conversation."""
+        storage = self._get_storage()
+        if storage is None:
+            self.error(
+                response={"message": "Chat storage not available"},
+                status=503,
+            )
+
+        user_id = await self._get_user_id()
+        if not user_id:
+            self.error(
+                response={"message": "User ID not found in session"},
+                status=401,
+            )
+
+        session_id = self.request.match_info.get("session_id")
+        if not session_id:
+            self.error(
+                response={"message": "session_id is required in path"},
+                status=400,
+            )
+
+        try:
+            body = await self.json_data()
+        except Exception:
+            body = {}
+
+        action = body.get("action")
+        if action != "delete_turn":
+            self.error(
+                response={"message": f"Unknown action: {action}"},
+                status=400,
+            )
+
+        turn_id = body.get("turn_id")
+        if not turn_id:
+            self.error(
+                response={"message": "turn_id is required"},
+                status=400,
+            )
+
+        deleted = await storage.delete_turn(
+            session_id=session_id,
+            turn_id=turn_id,
+        )
+
+        if deleted:
+            return self.json_response({
+                "message": f"Turn {turn_id} deleted",
+                "session_id": session_id,
+                "turn_id": turn_id,
+            })
+        self.error(
+            response={"message": f"Turn {turn_id} not found"},
+            status=404,
+        )

parrot/storage/chat.py

@@ -603,6 +603,42 @@ async def delete_conversation(
 
         return deleted
 
+    async def delete_turn(
+        self,
+        session_id: str,
+        turn_id: str,
+    ) -> bool:
+        """Delete a single turn (user + assistant messages) by turn_id.
+
+        Returns:
+            True if deletion succeeded.
+        """
+        if not self._docdb:
+            return False
+        try:
+            await self._docdb.delete_many(
+                MESSAGES_COLLECTION,
+                {"session_id": session_id, "turn_id": turn_id},
+            )
+            self.logger.debug(
+                f"Deleted turn {turn_id} from session {session_id}"
+            )
+            # Decrement message count on conversation metadata
+            try:
+                await self._docdb.update_one(
+                    CONVERSATIONS_COLLECTION,
+                    {"session_id": session_id},
+                    {"$inc": {"message_count": -2}},
+                )
+            except Exception:
+                pass  # Non-critical
+            return True
+        except Exception as exc:
+            self.logger.warning(
+                f"delete_turn failed for {turn_id} in {session_id}: {exc}"
+            )
+            return False
+
     async def get_context_for_agent(
         self,
         user_id: str,

parrot/tools/prophetforecast.py

@@ -89,8 +89,38 @@ async def _execute(self, **kwargs: Any) -> ToolResult:
         return await loop.run_in_executor(None, self._run_forecast, args)
 
     def _run_forecast(self, args: ProphetForecastArgs) -> ToolResult:
-        dataframe = self._resolve_dataframe(args.dataframe)
-        cleaned_df = self._prepare_dataframe(dataframe, args)
+        # Resolve DataFrame with recoverable error handling
+        try:
+            dataframe = self._resolve_dataframe(args.dataframe)
+        except ValueError as e:
+            # Return recoverable error so LLM can retry with correct DataFrame
+            return ToolResult(
+                success=False,
+                status="error",
+                result=None,
+                error=str(e),
+                metadata={
+                    "requested_dataframe": args.dataframe,
+                    "available_dataframes": list(self.dataframes.keys()),
+                    "recoverable": True,
+                },
+            )
+
+        # Prepare DataFrame with recoverable error handling
+        try:
+            cleaned_df = self._prepare_dataframe(dataframe, args)
+        except ValueError as e:
+            return ToolResult(
+                success=False,
+                status="error",
+                result=None,
+                error=str(e),
+                metadata={
+                    "dataframe": args.dataframe,
+                    "available_columns": list(dataframe.columns),
+                    "recoverable": True,
+                },
+            )
 
         model = Prophet()
         model.fit(cleaned_df)