Your task is to review pull requests. Instructions:
- Provide the response in following JSON format: {"reviews": [{"line": <line_number>, "body": "<review comment>"}]}
- Do not give positive comments or compliments.
- Provide comments and suggestions ONLY if there is something to improve, otherwise "reviews" should be an empty array.
- Write the comment in GitHub Markdown format.
- Use the given description only for the overall context and only comment the code.
- IMPORTANT: NEVER suggest adding comments to the code.

Review the following code diff in the file "g4f/gui/server/api.py" and take the pull request title and description into account when writing the response.
  
Pull request title: Add new provider, enhance functionality, and update docs
Pull request description:
---
## # New provider added
   - **g4f/Provider/GizAI.py**
      - **Text generation:** `gemini-flash, gemini-pro, gpt-4o-mini, gpt-4o, claude-3.5-sonnet, claude-3-haiku, llama-3.1-70b, llama-3.1-8b, mistral-large`
      - **Image generation:** `sdxl, sd-1.5, sd-3.5, flux-schnell`
---



## G4F update
## # New feature added to G4F for anthropics
**(g4f/client/client.py): add system prompt support**
   - Enhance the Completions class by adding support for system prompts
      - Introduce a 'system' parameter to the create and async_create methods
      - Prepend the system message to the user messages if provided

> This change improves flexibility and aligns with best practices seen in APIs like Anthropic's, allowing better management of system-level instructions.

> **Reference:** [docs.anthropic](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/system-prompts#financial-analysis-without-role-prompting)


**Sample use of the new feature:**
**G4F Client**
```python
from g4f.client import Client

client = Client()

response = client.chat.completions.create(
    system="You are a helpful assistant.",
    model="gpt-3.5-turbo",
    messages=[
        {
            "role": "user",
            "content": "Say this is a test"
        }
    ]
    # Add any other necessary parameters
)

print(response.choices[0].message.content)
```

**G4F async client**
```python
import asyncio
from g4f.client import Client

async def main():
    client = Client()
    
    response = await client.chat.completions.async_create(
        system="You are a helpful assistant.", # <-- role prompt
        model="gpt-3.5-turbo",
        messages=[
            {
                "role": "user",
                "content": "Say this is a test"
            }
        ]
    )
    
    print(response.choices[0].message.content)

asyncio.run(main())
```


---
## # New feature added to Images Album G4F-GUI

**(g4f/gui/server/api.py): enhance image handling and directory management**
   - Enhance image handling functionalities and ensure image directory exists
      - Add ensure_images_dir function to create image directory if it doesn't exist
      - Modify serve_images and _copy_images methods to use ensure_images_dir
      - Remove unnecessary imports to clean up code
      - Update typing annotations to improve type safety

> This ensures that the directory for storing images is always present and improves code readability and maintainability.
---
**(g4f/gui/server/backend.py): add route to list generated images**
   - Introduce a new endpoint `/images` to list all generated images
   - Implement `get_images` method to retrieve and return image paths as JSON
   - Update `serve_images` method to serve images from the `./generated_images` directory
   - Enhance route registration to include the new `/images` endpoint

> This addition provides a way to dynamically list and access generated images via the API.
---
**(g4f/gui/server/website.py): add redirect for /images/ endpoint**
   - Add a new route '/images/' to the website routes configuration
      - The new route redirects to the home page similar to other routes
      - Supports both GET and POST methods

> This change ensures consistency in route management and better handles potential future expansion for the '/images/' endpoint.
---
**(g4f/gui/client/index.html): add image album and enhance model/provider options**
   - Added "Images Album" button in the bottom_buttons section for easier access to image-related functionalities.
   - Enhanced model selection options by adding new models such as gpt-4o, gpt-4o-mini, llama-3.1-405b, mixtral-8x7b, gemini-flash, claude-3-haiku, and claude-3.5-sonnet.
   - Enhanced provider selection options by adding new providers such as DeepInfraChat, ReplicateHome, Blackbox, HuggingChat, DDG, and Pizzagpt.
   - Introduced an image modal with navigation controls for better image viewing experience.

> These changes improve the user interface by adding new functionalities and expanding the available options for models and providers.
---
**(g4f/gui/client/static/css/style.css): add image modal and navigation controls**
   - Implemented a modal for displaying images in larger view with navigation controls.
      - Added styles for album images, modal, and navigation buttons.
      - Included close button and image counter within the modal.
      - Updated the blink animation for better visual feedback.
---
**(g4f/gui/client/static/js/chat.v1.js): add image album functionality**
   - Implement functionality to load, display, and navigate through images
      - Fetch images from the server and display them in the album
      - Add modal to view images in a larger format with zoom functionality
      - Allow navigation between images using arrow keys and buttons

**Changes:**
   - Added `loadImages`, `displayImages`, `openImageModal`, and navigation functions
   - Modified event listeners for image inputs and modal interactions
   - Updated CSS classes for hidden states and image styling
---


## # G4F improvements
**(g4f/api/__init__.py): refactor API structure and improve async handling**
   - Updated `create_app` to accept an optional `g4f_api_key` parameter.
   - Refactored `ChatCompletionsForm` to `ChatCompletionsConfig` and `ImagesGenerateForm` to `ImageGenerationConfig`.
   - Improved async handling for `chat_completions` and `generate_image` endpoints.
   - Added type hints for better readability and maintainability.
   - Updated routes to include `/v1/images/generate`.
   - Enhanced error handling and logging.
   - Introduced global `list_ignored_providers` and related setter method.

> Breaking change: Some API endpoints and request/response formats have been modified.
> https://github.com/xtekky/gpt4free/issues/2222#issue-2521995710
---
**(g4f/models.py): add new provider GizAI and update best providers**
   Add GizAI as a new provider for various models and update best provider lists
      - Add GizAI to the imports and update best provider lists for several models
      - Update `default` model's best providers
      - Adjust `gpt-4o`, `gpt-4o-mini`, `gpt-4`, `o1-mini`, `llama-3.1-8b`, `llama-3.1-70b`, `mistral-large`, `claude-3-haiku`, `claude-3.5-sonnet`, `gemini-pro`, `gemini-flash`, `sd-1.5`, `sd-3.5`, and `flux-schnell` to include GizAI

> Breaking change: Best provider logic updated to include new provider
---



## # Updating documentation and improving G4F
**(README.md): update README with badges and links**
   - Add new badges for commits, issues, and license at the top for improved visibility
   - Enhance author attribution with centered formatting
   - Correct various internal links within the Table of Contents
   - Fix broken link to the Interference API documentation
   - Adjust formatting for better readability and consistency throughout the file
   
   - Correct typo in the "Latest version" note and update internal links
      - Fix "Lastet" to "Latest" in the version note section
      - Update "Installation Guide for Windows (.exe)" link in the What's New section
      - Update link formats for internal references and external URLs
---
**(docs/async_client.md): update guide with Anthropic compatibility and improved chat completions example**
   - Add compatibility note for Anthropic API
   - Introduce new section for creating chat completions with an improved example
   - Update table of contents to include new section

> This update enhances the guide by providing clearer instructions for developers familiar with the OpenAI and Anthropic interfaces, making the transition to G4F smoother. The improved example helps developers understand how to create chat completions more effectively.
---
**(docs/client.md): update G4F Client API guide**
   - Update the G4F Client API guide to include new sections and examples:
      - Added section `Creating Chat Completions`
      - Improved example for creating chat completions with system message
      - Updated `Introduction` to mention Anthropic client compatibility
      - Minor text and format adjustments for clarity and completeness
---
**(docs/interference-api.md): update Interference API usage guide**
   - Enhance the Interference API usage guide with detailed instructions and examples for better clarity and usability.
      - Added sections for "Using the Interference API" and "Basic Usage"
      - Introduced example curl commands for text and image generation
      - Updated existing examples with improved formatting and explanations
      - Included a "Conclusion" section to summarize the guide's content
      - Defined how to run the API from both PyPI and the repository more clearly

> These updates aim to provide a more comprehensive and user-friendly guide for integrating G4F with OpenAI-based applications.
---

---

Each line is prefixed by its number. Code to review:
```
2: 
3: import logging
4: import os
-import os.path
5: import uuid
6: import asyncio
7: import time
8: from aiohttp import ClientSession
-from typing import Iterator, Optional
9:+from typing import Iterator, Optional, AsyncIterator, Union
10: from flask import send_from_directory
11: 
12: from g4f import version, models
19: from g4f.providers.base_provider import ProviderModelMixin, FinishReason
20: from g4f.providers.conversation import BaseConversation
21: 
-conversations: dict[dict[str, BaseConversation]] = {}
22:+# Define the directory for generated images
23: images_dir = "./generated_images"
24: 
25:+# Function to ensure the images directory exists
26:+def ensure_images_dir():
27:+    if not os.path.exists(images_dir):
28:+        os.makedirs(images_dir)
29:+
30:+conversations: dict[dict[str, BaseConversation]] = {}
31:+
32: 
33: class Api:
34:     @staticmethod
35:     def get_models() -> list[str]:
-        """
-        Return a list of all models.
-
-        Fetches and returns a list of all available models in the system.
-
-        Returns:
-            List[str]: A list of model names.
-        """
36:         return models._all_models
37: 
38:     @staticmethod
80: 
81:     @staticmethod
82:     def get_providers() -> list[str]:
-        """
-        Return a list of all working providers.
-        """
83:         return {
84:             provider.__name__: (
85:                 provider.label if hasattr(provider, "label") else provider.__name__
94: 
95:     @staticmethod
96:     def get_version():
-        """
-        Returns the current and latest version of the application.
-
-        Returns:
-            dict: A dictionary containing the current and latest version.
-        """
97:         try:
98:             current_version = version.utils.current_version
99:         except VersionNotFoundError:
104:         }
105: 
106:     def serve_images(self, name):
107:+        ensure_images_dir()
108:         return send_from_directory(os.path.abspath(images_dir), name)
109: 
110:     def _prepare_conversation_kwargs(self, json_data: dict, kwargs: dict):
-        """
-        Prepares arguments for chat completion based on the request data.
-
-        Reads the request and prepares the necessary arguments for handling 
-        a chat completion request.
-
-        Returns:
-            dict: Arguments prepared for chat completion.
-        """
111:         model = json_data.get('model') or models.default
112:         provider = json_data.get('provider')
113:         messages = json_data['messages']
140:             result = ChatCompletion.create(**kwargs)
141:             first = True
142:             if isinstance(result, ImageResponse):
-                # Якщо результат є ImageResponse, обробляємо його як одиночний елемент
143:                 if first:
144:                     first = False
145:                     yield self._format_json("provider", get_last_provider(True))
146:                 yield self._format_json("content", str(result))
147:             else:
-                # Якщо результат є ітерабельним, обробляємо його як раніше
148:                 for chunk in result:
149:                     if first:
150:                         first = False
160:                     elif isinstance(chunk, ImagePreview):
161:                         yield self._format_json("preview", chunk.to_string())
162:                     elif isinstance(chunk, ImageResponse):
-                        # Обробка ImageResponse
163:                         images = asyncio.run(self._copy_images(chunk.get_list(), chunk.options.get("cookies")))
164:                         yield self._format_json("content", str(ImageResponse(images, chunk.alt)))
165:                     elif not isinstance(chunk, FinishReason):
168:             logging.exception(e)
169:             yield self._format_json('error', get_error_message(e))
170: 
-    # Додайте цей метод до класу Api
171:     async def _copy_images(self, images: list[str], cookies: Optional[Cookies] = None):
172:+        ensure_images_dir()
173:         async with ClientSession(
174:             connector=get_connector(None, os.environ.get("G4F_PROXY")),
175:             cookies=cookies
190:             return await asyncio.gather(*[copy_image(image) for image in images])
191: 
192:     def _format_json(self, response_type: str, content):
-        """
-        Formats and returns a JSON response.
-
-        Args:
-            response_type (str): The type of the response.
-            content: The content to be included in the response.
-
-        Returns:
-            str: A JSON formatted string.
-        """
193:         return {
194:             'type': response_type,
195:             response_type: content
197: 
198: 
199: def get_error_message(exception: Exception) -> str:
-    """
-    Generates a formatted error message from an exception.
-
-    Args:
-        exception (Exception): The exception to format.
-
-    Returns:
-        str: A formatted error message string.
-    """
200:     message = f"{type(exception).__name__}: {exception}"
201:     provider = get_last_provider()
202:     if provider is None:
```