ai: Modularize client logic into separate components.

* Moved audio, image, and deep search handlers.
* Centralized input parsing and history management.
* Applied single-responsibility principle to streamline logic flow.

[i] Prepares the code for scalability as new features are added.

src/client/chat_handler.py

@@ -10,14 +10,14 @@ from config import model  # Import model configuration dictionary from config mo
 from src.core.server import jarvis  # Import the async function to interact with AI backend
 from src.core.parameter import parameters  # Import parameters (not used directly here but imported for completeness)
 from src.core.session import session  # Import session dictionary to store conversation histories
-from src.tools.audio import AudioGeneration  # Import AudioGeneration class to handle audio creation
-from src.tools.image import ImageGeneration  # Import ImageGeneration class to handle image creation
-from src.tools.deep_search import SearchTools  # Import SearchTools class for deep search functionality
+from src.utils.input import extract_input_and_files  # Import utility to extract input and files from message
+from src.utils.history import convert_history  # Import utility to convert history format
+from src.client.responses.audio import audio_integration  # Import handler for audio generation
+from src.client.responses.image import image_integration  # Import handler for image generation
+from src.client.responses.deep_search import deep_search_integration  # Import handler for deep search
 import gradio as gr  # Import Gradio library for UI and request handling
 
-# Define an asynchronous function 'respond' to process user messages and generate AI responses
-# This function handles various types of user inputs including text, commands, and file uploads
-# It supports multiple AI models and generation modes with customizable parameters
+# Define the asynchronous respond function to process user messages and generate AI responses
 async def respond(
     message,  # Incoming user message, can be a string or a dictionary containing text and files
     history: List[Any],  # List containing conversation history as pairs of user and assistant messages
@@ -34,353 +34,96 @@ async def respond(
     request: gr.Request  # Gradio request object to access session information such as session hash
 ):
     # Select the AI model based on the provided label, fallback to first model if label not found
-    selected_model = model.get(model_label, list(model.values())[0])
-    
-    # Instantiate SearchTools class to enable deep search capabilities when requested by user
-    search_tools = SearchTools()
-    
+    selected_model = model.get(model_label, list(model.values())[0])  # Choose model based on label
+
     # Retrieve session ID from the Gradio request's session hash, generate new UUID if none exists
-    session_id = request.session_hash or str(uuid.uuid4())
+    session_id = request.session_hash or str(uuid.uuid4())  # Get or create session ID
 
     # Initialize an empty conversation history list for this session if it does not already exist
-    if session_id not in session:
-        session[session_id] = []
+    if session_id not in session:  # Check if session ID is not in session dictionary
+        session[session_id] = []  # Initialize empty history for new session
 
     # Determine the mode string based on the 'thinking' flag, affects AI response generation behavior
-    mode = "/think" if thinking else "/no_think"
-
-    # Initialize variables for storing user input text and any attached files
-    input = ""
-    files = None
+    mode = "/think" if thinking else "/no_think"  # Set mode based on thinking flag
 
-    # Check if the incoming message is a dictionary which may contain both text and file attachments
-    if isinstance(message, dict):
-        # Extract the text content from the message dictionary, default to empty string if missing
-        input = message.get("text", "")
-        # Extract the first file from the files list if present, otherwise set files to None
-        files = message.get("files")[0] if message.get("files") else None
-    else:
-        # If the message is a simple string, assign it directly to input variable
-        input = message
+    # Extract input text and files from the message using utility function
+    input, files = extract_input_and_files(message)  # Unpack input and files
 
     # Strip leading and trailing whitespace from the input for clean processing
-    stripped_input = input.strip()
+    stripped_input = input.strip()  # Remove whitespace from input
     # Convert the stripped input to lowercase for case-insensitive command detection
-    lowered_input = stripped_input.lower()
+    lowered_input = stripped_input.lower()  # Convert input to lowercase
 
     # If the input is empty after stripping whitespace, yield an empty list and exit function early
-    if not stripped_input:
-        yield []
-        return
+    if not stripped_input:  # Check if input is empty
+        yield []  # Yield empty list for empty input
+        return  # Exit function
 
     # If the input is exactly one of the command keywords without parameters, yield empty and exit early
-    if lowered_input in ["/audio", "/image", "/dp"]:
-        yield []
-        return
+    if lowered_input in ["/audio", "/image", "/dp"]:  # Check for command keywords only
+        yield []  # Yield empty list for bare command
+        return  # Exit function
 
     # Convert conversation history from tuples style to messages style format for AI model consumption
-    # Transform list of [user_msg, assistant_msg] pairs into flat list of role-content dictionaries
-    new_history = []
-    for entry in history:
-        # Ensure the entry is a list with exactly two elements: user message and assistant message
-        if isinstance(entry, list) and len(entry) == 2:
-            user_msg, assistant_msg = entry
-            # Append the user message with role 'user' to the new history if message is not None
-            if user_msg is not None:
-                new_history.append({"role": "user", "content": user_msg})
-            # Append the assistant message with role 'assistant' if it exists and is not None
-            if assistant_msg is not None:
-                new_history.append({"role": "assistant", "content": assistant_msg})
+    new_history = convert_history(history)  # Convert history to message format
 
     # Update the global session dictionary with the newly formatted conversation history for this session
-    session[session_id] = new_history
+    session[session_id] = new_history  # Update session with new history
 
     # Handle audio generation command if enabled and input starts with '/audio' prefix
-    if audio_gen and lowered_input.startswith("/audio"):
-        # Extract the audio instruction text after the '/audio' command prefix and strip whitespace
-        audio_instruction = input[6:].strip()
-        # If no instruction text is provided after the command, yield empty and exit early
-        if not audio_instruction:
-            yield []
-            return
-        try:
-            # Asynchronously create audio content based on the instruction using AudioGeneration class
-            audio = await AudioGeneration.create_audio(audio_instruction)
-            # Serialize the audio data and instruction into a JSON formatted string for processing
-            audio_generation_content = json.dumps({
-                "audio": audio,
-                "audio_instruction": audio_instruction
-            })
-            # Construct the conversation history including the audio generation result and formatting instructions
-            audio_generation_result = (
-                new_history
-                + [
-                    {
-                        "role": "system",
-                        "content": (
-                            "Audio generation result:\n\n" + audio_generation_content + "\n\n\n"
-                            "Show the audio using the following HTML audio tag format, where '{audio_link}' is the URL of the generated audio:\n\n"
-                            "<audio controls src='{audio_link}' style='width:100%; max-width:100%;'></audio>\n\n"
-                            "Please replace '{audio_link}' with the actual audio URL provided in the context.\n\n"
-                            "Then, describe the generated audio based on the above information.\n\n\n"
-                            "Use the same language as the previous user input or user request.\n"
-                            "For example, if the previous user input or user request is in Indonesian, explain in Indonesian.\n"
-                            "If it is in English, explain in English. This also applies to other languages.\n\n\n"
-                        )
-                    }
-                ]
-            )
-
-            # Use async generator to get descriptive text about the generated audio from AI
-            async for audio_description in jarvis(
-                session_id=session_id,
-                model=selected_model,
-                history=audio_generation_result,
-                user_message=input,
-                mode="/no_think",  # Use non-reasoning mode to avoid extra processing overhead
-                temperature=0.7,  # Fixed temperature for consistent audio description generation
-                top_k=20,  # Limit token sampling to top 20 most probable tokens
-                min_p=0,  # Minimum probability threshold set to zero
-                top_p=0.8,  # Nucleus sampling threshold for quality control
-                repetition_penalty=1  # No repetition penalty for this step
-            ):
-                # Yield the audio description wrapped in a tool role for proper UI display
-                yield [{"role": "tool", "content": audio_description}]
-            return
-        except Exception:
-            # If audio generation fails, let AI generate a contextual error message
-            generation_failed = (
-                new_history
-                + [
-                    {
-                        "role": "system",
-                        "content": (
-                            "Audio generation failed for the user's request. The user tried to generate audio with the instruction: '"
-                            + audio_instruction + "'\n\n\n"
-                            "Please explain to the user that audio generation failed and suggest they wait 15 seconds before trying again.\n"
-                            "Be helpful and empathetic in your response.\n\n\n"
-                            "Use the same language as the previous user input or user request.\n"
-                            "For example, if the previous user input or user request is in Indonesian, explain in Indonesian.\n"
-                            "If it is in English, explain in English. This also applies to other languages.\n\n\n"
-                        )
-                    }
-                ]
-            )
-            
-            # Use AI to generate a contextual error message
-            async for error_response in jarvis(
-                session_id=session_id,
-                model=selected_model,
-                history=generation_failed,
-                user_message=input,
-                mode="/no_think",  # Use non-reasoning mode for error handling
-                temperature=0.7,  # Fixed temperature for more consistent error messages
-                top_k=20,  # Limit token sampling
-                min_p=0,  # Minimum probability threshold
-                top_p=0.8,  # Nucleus sampling threshold
-                repetition_penalty=1  # No repetition penalty
-            ):
-                # Yield the AI-generated error response wrapped in tool role
-                yield [{"role": "tool", "content": error_response}]
-            return
+    if audio_gen and lowered_input.startswith("/audio"):  # Check for audio command
+        async for audio_response in audio_integration(
+            input,  # User input
+            new_history,  # Conversation history
+            session_id,  # Session ID
+            selected_model,  # Selected model
+            jarvis  # AI backend function
+        ):
+            yield audio_response  # Yield audio response
+        return  # Exit function after handling audio
 
     # Handle image generation command if enabled and input starts with '/image' prefix
-    if image_gen and lowered_input.startswith("/image"):
-        # Extract the image generation instruction after the '/image' command prefix and strip whitespace
-        generate_image_instruction = input[6:].strip()
-        # If no instruction text is provided after the command, yield empty and exit early
-        if not generate_image_instruction:
-            yield []
-            return
-        try:
-            # Asynchronously create image content based on the instruction using ImageGeneration class
-            image = await ImageGeneration.create_image(generate_image_instruction)
-
-            # Serialize the image data and instruction into a JSON formatted string for processing
-            image_generation_content = json.dumps({
-                "image": image,
-                "generate_image_instruction": generate_image_instruction
-            })
-
-            # Construct the conversation history including the image generation result and formatting instructions
-            image_generation_result = (
-                new_history
-                + [
-                    {
-                        "role": "system",
-                        "content": (
-                            "Image generation result:\n\n" + image_generation_content + "\n\n\n"
-                            "Show the generated image using the following markdown syntax format, where '{image_link}' is the URL of the image:\n\n"
-                            "![Generated Image]({image_link})\n\n"
-                            "Please replace '{image_link}' with the actual image URL provided in the context.\n\n"
-                            "Then, describe the generated image based on the above information.\n\n\n"
-                            "Use the same language as the previous user input or user request.\n"
-                            "For example, if the previous user input or user request is in Indonesian, explain in Indonesian.\n"
-                            "If it is in English, explain in English. This also applies to other languages.\n\n\n"
-                        )
-                    }
-                ]
-            )
-
-            # Use async generator to get descriptive text about the generated image from AI
-            async for image_description in jarvis(
-                session_id=session_id,
-                model=selected_model,
-                history=image_generation_result,
-                user_message=input,
-                mode="/no_think",  # Use non-reasoning mode to avoid extra processing overhead
-                temperature=0.7,  # Fixed temperature for consistent image description generation
-                top_k=20,  # Limit token sampling to top 20 most probable tokens
-                min_p=0,  # Minimum probability threshold set to zero
-                top_p=0.8,  # Nucleus sampling threshold for quality control
-                repetition_penalty=1 # No repetition penalty for this step
-            ):
-                # Yield the image description wrapped in a tool role for proper UI display
-                yield [{"role": "tool", "content": image_description}]
-            return
-        except Exception:
-            # If image generation fails, let AI generate a contextual error message
-            generation_failed = (
-                new_history
-                + [
-                    {
-                        "role": "system",
-                        "content": (
-                            "Image generation failed for the user's request. The user tried to generate an image with the instruction: '"
-                            + generate_image_instruction + "'\n\n\n"
-                            "Please explain to the user that image generation failed and suggest they wait 15 seconds before trying again.\n"
-                            "Be helpful and empathetic in your response.\n\n\n"
-                            "Use the same language as the previous user input or user request.\n"
-                            "For example, if the previous user input or user request is in Indonesian, explain in Indonesian.\n"
-                            "If it is in English, explain in English. This also applies to other languages.\n\n\n"
-                        )
-                    }
-                ]
-            )
-            
-            # Use AI to generate a contextual error message
-            async for error_response in jarvis(
-                session_id=session_id,
-                model=selected_model,
-                history=generation_failed,
-                user_message=input,
-                mode="/no_think",  # Use non-reasoning mode for error handling
-                temperature=0.7,  # Fixed temperature for more consistent error messages
-                top_k=20,  # Limit token sampling
-                min_p=0,  # Minimum probability threshold
-                top_p=0.8,  # Nucleus sampling threshold
-                repetition_penalty=1  # No repetition penalty
-            ):
-                # Yield the AI-generated error response wrapped in tool role
-                yield [{"role": "tool", "content": error_response}]
-            return
+    if image_gen and lowered_input.startswith("/image"):  # Check for image command
+        async for image_response in image_integration(
+            input,  # User input
+            new_history,  # Conversation history
+            session_id,  # Session ID
+            selected_model,  # Selected model
+            jarvis  # AI backend function
+        ):
+            yield image_response  # Yield image response
+        return  # Exit function after handling image
 
     # Handle deep search command if enabled and input starts with '/dp' prefix
-    if search_gen and lowered_input.startswith("/dp"):
-        # Extract the search query after the '/dp' command prefix and strip whitespace
-        search_query = input[3:].strip()
-        # If no search query is provided after the command, yield empty and exit early
-        if not search_query:
-            yield []
-            return
-        
-        try:
-            # Perform an asynchronous deep search using SearchTools with the given query
-            search_results = await search_tools.search(search_query)
-
-            # Serialize the search query and results (limited to first 5000 characters) into JSON string
-            search_content = json.dumps({
-                "query": search_query,
-                "search_results": search_results[:5000]
-            })
-            
-            # Construct conversation history including deep search results and detailed instructions for summarization
-            search_instructions = (
-                new_history
-                + [
-                    {
-                        "role": "system",
-                        "content": (
-                            "Deep search results for query: '" + search_query + "':\n\n\n" + search_content + "\n\n\n"
-                            "Please analyze these search results and provide a comprehensive summary of the information.\n"
-                            "Identify the most relevant information related to the query.\n"
-                            "Format your response in a clear, structured way with appropriate headings and bullet points if needed.\n"
-                            "If the search results don't provide sufficient information, acknowledge this limitation.\n"
-                            "Please provide links or URLs from each of your search results.\n\n\n"
-                            "Use the same language as the previous user input or user request.\n"
-                            "For example, if the previous user input or user request is in Indonesian, explain in Indonesian.\n"
-                            "If it is in English, explain in English. This also applies to other languages.\n\n\n"
-                        )
-                    }
-                ]
-            )
-
-            # Use async generator to process the deep search results and generate a summary response
-            async for search_response in jarvis(
-                session_id=session_id,
-                model=selected_model,
-                history=search_instructions,
-                user_message=input,
-                mode=mode,  # Use the mode determined by the thinking flag
-                temperature=temperature,
-                top_k=top_k,
-                min_p=min_p,
-                top_p=top_p,
-                repetition_penalty=repetition_penalty
-            ):
-                # Yield the search summary wrapped in a tool role for proper UI display
-                yield [{"role": "tool", "content": search_response}]
-            return
-            
-        except Exception as e:
-            # If deep search fails, let AI generate a contextual error message
-            generation_failed = (
-                new_history
-                + [
-                    {
-                        "role": "system",
-                        "content": (
-                            "Deep search failed for the user's query: '" + search_query + "'\n\n\n"
-                            "Please explain to the user that the search operation failed and suggest they try again later.\n"
-                            "Be helpful and empathetic in your response. You can also suggest alternative approaches or workarounds.\n\n\n"
-                            "Use the same language as the previous user input or user request.\n"
-                            "For example, if the previous user input or user request is in Indonesian, explain in Indonesian.\n"
-                            "If it is in English, explain in English. This also applies to other languages.\n\n\n"
-                        )
-                    }
-                ]
-            )
-            
-            # Use AI to generate a contextual error message
-            async for error_response in jarvis(
-                session_id=session_id,
-                model=selected_model,
-                history=generation_failed,
-                user_message=input,
-                mode="/no_think",  # Use non-reasoning mode for error handling
-                temperature=0.7,  # Fixed temperature for more consistent error messages
-                top_k=20,  # Limit token sampling
-                min_p=0,  # Minimum probability threshold
-                top_p=0.8,  # Nucleus sampling threshold
-                repetition_penalty=1  # No repetition penalty
-            ):
-                # Yield the AI-generated error response wrapped in tool role
-                yield [{"role": "tool", "content": error_response}]
-            return
+    if search_gen and lowered_input.startswith("/dp"):  # Check for deep search command
+        async for search_response in deep_search_integration(
+            input,  # User input
+            new_history,  # Conversation history
+            session_id,  # Session ID
+            selected_model,  # Selected model
+            jarvis,  # AI backend function
+            mode,  # Mode for AI response
+            temperature,  # temperature parameter
+            top_k,  # top_k parameter
+            min_p,  # min_p parameter
+            top_p,  # top_p parameter
+            repetition_penalty  # repetition_penalty parameter
+        ):
+            yield search_response  # Yield search response
+        return  # Exit function after handling deep search
 
     # For all other inputs that do not match special commands, use the jarvis function to generate a normal response
     async for response in jarvis(
-        session_id=session_id,
-        model=selected_model,
+        session_id=session_id,  # Session ID for conversation context
+        model=selected_model,  # Selected model for generation
         history=new_history,  # Pass the conversation history
-        user_message=input,
+        user_message=input,  # User input message
         mode=mode,  # Use the mode determined by the thinking flag
         files=files,  # Pass any attached files along with the message
-        temperature=temperature,
-        top_k=top_k,
-        min_p=min_p,
-        top_p=top_p,
-        repetition_penalty=repetition_penalty
+        temperature=temperature,  # temperature parameter
+        top_k=top_k,  # top_k parameter
+        min_p=min_p,  # min_p parameter
+        top_p=top_p,  # top_p parameter
+        repetition_penalty=repetition_penalty  # repetition_penalty parameter
     ):
-        # Yield each chunk of the response as it is generated by the AI model
-        yield response
+        yield response  # Yield each chunk of the response as it is generated by the AI model

src/client/responses/audio.py

@@ -0,0 +1,105 @@
+#
+# SPDX-FileCopyrightText: Hadad <[email protected]>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import json  # Import JSON module for encoding and decoding JSON data
+from src.tools.audio import AudioGeneration  # Import AudioGeneration class to handle audio creation
+
+# Asynchronous handler for audio generation command
+async def audio_integration(
+    input,  # User input containing the /audio command and instruction
+    new_history,  # Conversation history in message format
+    session_id,  # Session ID for conversation context
+    selected_model,  # Selected AI model for generation
+    jarvis  # AI backend function for generating responses
+):
+    # Extract the audio instruction text after the '/audio' command prefix and strip whitespace
+    audio_instruction = input[6:].strip()  # Get instruction after /audio
+
+    # If no instruction text is provided after the command, yield empty and exit early
+    if not audio_instruction:  # Check if instruction is empty
+        yield []  # Yield empty list for missing instruction
+        return  # Exit function
+
+    try:  # Try block for audio generation
+        # Asynchronously create audio content based on the instruction using AudioGeneration class
+        audio = await AudioGeneration.create_audio(audio_instruction)  # Generate audio
+
+        # Serialize the audio data and instruction into a JSON formatted string for processing
+        audio_generation_content = json.dumps({
+            "audio": audio,  # Audio content or URL
+            "audio_instruction": audio_instruction  # Instruction for audio generation
+        })
+
+        # Construct the conversation history including the audio generation result and formatting instructions
+        audio_generation_result = (
+            new_history
+            + [
+                {
+                    "role": "system",
+                    "content": (
+                        "Audio generation result:\n\n" + audio_generation_content + "\n\n\n"
+                        "Show the audio using the following HTML audio tag format, where '{audio_link}' is the URL of the generated audio:\n\n"
+                        "<audio controls src='{audio_link}' style='width:100%; max-width:100%;'></audio>\n\n"
+                        "Please replace '{audio_link}' with the actual audio URL provided in the context.\n\n"
+                        "Then, describe the generated audio based on the above information.\n\n\n"
+                        "Use the same language as the previous user input or user request.\n"
+                        "For example, if the previous user input or user request is in Indonesian, explain in Indonesian.\n"
+                        "If it is in English, explain in English. This also applies to other languages.\n\n\n"
+                    )
+                }
+            ]
+        )
+
+        # Use async generator to get descriptive text about the generated audio from AI
+        async for audio_description in jarvis(
+            session_id=session_id,  # Session ID
+            model=selected_model,  # Selected model
+            history=audio_generation_result,  # Updated history with audio result
+            user_message=input,  # User input
+            mode="/no_think",  # Use non-reasoning mode to avoid extra processing overhead
+            temperature=0.7,  # Fixed temperature for consistent audio description generation
+            top_k=20,  # Limit token sampling to top 20 most probable tokens
+            min_p=0,  # Minimum probability threshold set to zero
+            top_p=0.8,  # Nucleus sampling threshold for quality control
+            repetition_penalty=1  # No repetition penalty for this step
+        ):
+            yield [{"role": "tool", "content": audio_description}]  # Yield audio description in tool role
+        return  # Exit after handling audio
+
+    except Exception:  # Exception handling for audio generation failure
+        # If audio generation fails, let AI generate a contextual error message
+        generation_failed = (
+            new_history
+            + [
+                {
+                    "role": "system",
+                    "content": (
+                        "Audio generation failed for the user's request. The user tried to generate audio with the instruction: '"
+                        + audio_instruction + "'\n\n\n"
+                        "Please explain to the user that audio generation failed and suggest they wait 15 seconds before trying again.\n"
+                        "Be helpful and empathetic in your response.\n\n\n"
+                        "Use the same language as the previous user input or user request.\n"
+                        "For example, if the previous user input or user request is in Indonesian, explain in Indonesian.\n"
+                        "If it is in English, explain in English. This also applies to other languages.\n\n\n"
+                    )
+                }
+            ]
+        )
+
+        # Use AI to generate a contextual error message
+        async for error_response in jarvis(
+            session_id=session_id,  # Session ID
+            model=selected_model,  # Selected model
+            history=generation_failed,  # History with error context
+            user_message=input,  # User input
+            mode="/no_think",  # Use non-reasoning mode for error handling
+            temperature=0.7,  # Fixed temperature for more consistent error messages
+            top_k=20,  # Limit token sampling
+            min_p=0,  # Minimum probability threshold
+            top_p=0.8,  # Nucleus sampling threshold
+            repetition_penalty=1  # No repetition penalty
+        ):
+            yield [{"role": "tool", "content": error_response}]  # Yield error response in tool role
+        return  # Exit after error handling

src/client/responses/deep_search.py

@@ -0,0 +1,114 @@
+#
+# SPDX-FileCopyrightText: Hadad <[email protected]>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import json  # Import JSON module for encoding and decoding JSON data
+from src.tools.deep_search import SearchTools  # Import SearchTools class for deep search functionality
+
+# Asynchronous handler for deep search command
+async def deep_search_integration(
+    input,  # User input containing the /dp command and query
+    new_history,  # Conversation history in message format
+    session_id,  # Session ID for conversation context
+    selected_model,  # Selected AI model for generation
+    jarvis,  # AI backend function for generating responses
+    mode,  # Mode for AI response generation
+    temperature,  # Temperature parameter for AI
+    top_k,  # Top-k parameter for AI
+    min_p,  # Min-p parameter for AI
+    top_p,  # Top-p parameter for AI
+    repetition_penalty  # Repetition penalty for AI
+):
+    # Instantiate SearchTools class to enable deep search capabilities when requested by user
+    search_tools = SearchTools()  # Create SearchTools instance
+
+    # Extract the search query after the '/dp' command prefix and strip whitespace
+    search_query = input[3:].strip()  # Get search query after /dp
+
+    # If no search query is provided after the command, yield empty and exit early
+    if not search_query:  # Check if search query is empty
+        yield []  # Yield empty list for missing search query
+        return  # Exit function
+
+    try:  # Try block for deep search
+        # Perform an asynchronous deep search using SearchTools with the given query
+        search_results = await search_tools.search(search_query)  # Perform deep search
+
+        # Serialize the search query and results (limited to first 5000 characters) into JSON string
+        search_content = json.dumps({
+            "query": search_query,  # Search query
+            "search_results": search_results[:5000]  # Search results limited to 5000 characters
+        })
+
+        # Construct conversation history including deep search results and detailed instructions for summarization
+        search_instructions = (
+            new_history
+            + [
+                {
+                    "role": "system",
+                    "content": (
+                        "Deep search results for query: '" + search_query + "':\n\n\n" + search_content + "\n\n\n"
+                        "Please analyze these search results and provide a comprehensive summary of the information.\n"
+                        "Identify the most relevant information related to the query.\n"
+                        "Format your response in a clear, structured way with appropriate headings and bullet points if needed.\n"
+                        "If the search results don't provide sufficient information, acknowledge this limitation.\n"
+                        "Please provide links or URLs from each of your search results.\n\n\n"
+                        "Use the same language as the previous user input or user request.\n"
+                        "For example, if the previous user input or user request is in Indonesian, explain in Indonesian.\n"
+                        "If it is in English, explain in English. This also applies to other languages.\n\n\n"
+                    )
+                }
+            ]
+        )
+
+        # Use async generator to process the deep search results and generate a summary response
+        async for search_response in jarvis(
+            session_id=session_id,  # Session ID
+            model=selected_model,  # Selected model
+            history=search_instructions,  # Updated history with search results
+            user_message=input,  # User input
+            mode=mode,  # Mode for AI response
+            temperature=temperature,  # temperature parameter
+            top_k=top_k,  # top_k parameter
+            min_p=min_p,  # min_p parameter
+            top_p=top_p,  # top_p parameter
+            repetition_penalty=repetition_penalty  # repetition_penalty parameter
+        ):
+            yield [{"role": "tool", "content": search_response}]  # Yield search summary in tool role
+        return  # Exit after handling deep search
+
+    except Exception as e:  # Exception handling for deep search failure
+        # If deep search fails, let AI generate a contextual error message
+        generation_failed = (
+            new_history
+            + [
+                {
+                    "role": "system",
+                    "content": (
+                        "Deep search failed for the user's query: '" + search_query + "'\n\n\n"
+                        "Please explain to the user that the search operation failed and suggest they try again later.\n"
+                        "Be helpful and empathetic in your response. You can also suggest alternative approaches or workarounds.\n\n\n"
+                        "Use the same language as the previous user input or user request.\n"
+                        "For example, if the previous user input or user request is in Indonesian, explain in Indonesian.\n"
+                        "If it is in English, explain in English. This also applies to other languages.\n\n\n"
+                    )
+                }
+            ]
+        )
+
+        # Use AI to generate a contextual error message
+        async for error_response in jarvis(
+            session_id=session_id,  # Session ID
+            model=selected_model,  # Selected model
+            history=generation_failed,  # History with error context
+            user_message=input,  # User input
+            mode="/no_think",  # Use non-reasoning mode for error handling
+            temperature=0.7,  # Fixed temperature for more consistent error messages
+            top_k=20,  # Limit token sampling
+            min_p=0,  # Minimum probability threshold
+            top_p=0.8,  # Nucleus sampling threshold
+            repetition_penalty=1  # No repetition penalty
+        ):
+            yield [{"role": "tool", "content": error_response}]  # Yield error response in tool role
+        return  # Exit after error handling

src/client/responses/image.py

@@ -0,0 +1,105 @@
+#
+# SPDX-FileCopyrightText: Hadad <[email protected]>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import json  # Import JSON module for encoding and decoding JSON data
+from src.tools.image import ImageGeneration  # Import ImageGeneration class to handle image creation
+
+# Asynchronous handler for image generation command
+async def image_integration(
+    input,  # User input containing the /image command and instruction
+    new_history,  # Conversation history in message format
+    session_id,  # Session ID for conversation context
+    selected_model,  # Selected AI model for generation
+    jarvis  # AI backend function for generating responses
+):
+    # Extract the image generation instruction after the '/image' command prefix and strip whitespace
+    generate_image_instruction = input[6:].strip()  # Get instruction after /image
+
+    # If no instruction text is provided after the command, yield empty and exit early
+    if not generate_image_instruction:  # Check if instruction is empty
+        yield []  # Yield empty list for missing instruction
+        return  # Exit function
+
+    try:  # Try block for image generation
+        # Asynchronously create image content based on the instruction using ImageGeneration class
+        image = await ImageGeneration.create_image(generate_image_instruction)  # Generate image
+
+        # Serialize the image data and instruction into a JSON formatted string for processing
+        image_generation_content = json.dumps({
+            "image": image,  # Image content or URL
+            "generate_image_instruction": generate_image_instruction  # Instruction for image generation
+        })
+
+        # Construct the conversation history including the image generation result and formatting instructions
+        image_generation_result = (
+            new_history
+            + [
+                {
+                    "role": "system",
+                    "content": (
+                        "Image generation result:\n\n" + image_generation_content + "\n\n\n"
+                        "Show the generated image using the following markdown syntax format, where '{image_link}' is the URL of the image:\n\n"
+                        "![Generated Image]({image_link})\n\n"
+                        "Please replace '{image_link}' with the actual image URL provided in the context.\n\n"
+                        "Then, describe the generated image based on the above information.\n\n\n"
+                        "Use the same language as the previous user input or user request.\n"
+                        "For example, if the previous user input or user request is in Indonesian, explain in Indonesian.\n"
+                        "If it is in English, explain in English. This also applies to other languages.\n\n\n"
+                    )
+                }
+            ]
+        )
+
+        # Use async generator to get descriptive text about the generated image from AI
+        async for image_description in jarvis(
+            session_id=session_id,  # Session ID
+            model=selected_model,  # Selected model
+            history=image_generation_result,  # Updated history with image result
+            user_message=input,  # User input
+            mode="/no_think",  # Use non-reasoning mode to avoid extra processing overhead
+            temperature=0.7,  # Fixed temperature for consistent image description generation
+            top_k=20,  # Limit token sampling to top 20 most probable tokens
+            min_p=0,  # Minimum probability threshold set to zero
+            top_p=0.8,  # Nucleus sampling threshold for quality control
+            repetition_penalty=1  # No repetition penalty for this step
+        ):
+            yield [{"role": "tool", "content": image_description}]  # Yield image description in tool role
+        return  # Exit after handling image
+
+    except Exception:  # Exception handling for image generation failure
+        # If image generation fails, let AI generate a contextual error message
+        generation_failed = (
+            new_history
+            + [
+                {
+                    "role": "system",
+                    "content": (
+                        "Image generation failed for the user's request. The user tried to generate an image with the instruction: '"
+                        + generate_image_instruction + "'\n\n\n"
+                        "Please explain to the user that image generation failed and suggest they wait 15 seconds before trying again.\n"
+                        "Be helpful and empathetic in your response.\n\n\n"
+                        "Use the same language as the previous user input or user request.\n"
+                        "For example, if the previous user input or user request is in Indonesian, explain in Indonesian.\n"
+                        "If it is in English, explain in English. This also applies to other languages.\n\n\n"
+                    )
+                }
+            ]
+        )
+
+        # Use AI to generate a contextual error message
+        async for error_response in jarvis(
+            session_id=session_id,  # Session ID
+            model=selected_model,  # Selected model
+            history=generation_failed,  # History with error context
+            user_message=input,  # User input
+            mode="/no_think",  # Use non-reasoning mode for error handling
+            temperature=0.7,  # Fixed temperature for more consistent error messages
+            top_k=20,  # Limit token sampling
+            min_p=0,  # Minimum probability threshold
+            top_p=0.8,  # Nucleus sampling threshold
+            repetition_penalty=1  # No repetition penalty
+        ):
+            yield [{"role": "tool", "content": error_response}]  # Yield error response in tool role
+        return  # Exit after error handling

src/utils/history.py

@@ -0,0 +1,25 @@
+#
+# SPDX-FileCopyrightText: Hadad <[email protected]>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+# Utility function to convert conversation history format for AI model consumption
+def convert_history(history):  # Convert history to message format
+    """
+    Converts a list of [user_msg, assistant_msg] pairs into a flat list of role-content dictionaries.
+    This format is required for AI model input.
+    """
+    new_history = []  # Initialize new history list
+
+    for entry in history:  # Iterate over each entry in history
+        # Ensure the entry is a list with exactly two elements: user message and assistant message
+        if isinstance(entry, list) and len(entry) == 2:  # Check entry structure
+            user_msg, assistant_msg = entry  # Unpack user and assistant messages
+
+            if user_msg is not None:  # Check if user message is not None
+                new_history.append({"role": "user", "content": user_msg})  # Add user message to new history
+
+            if assistant_msg is not None:  # Check if assistant message is not None
+                new_history.append({"role": "assistant", "content": assistant_msg})  # Add assistant message to new history
+
+    return new_history  # Return the converted history list

src/utils/input.py

@@ -0,0 +1,22 @@
+#
+# SPDX-FileCopyrightText: Hadad <[email protected]>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+# Utility function to extract input text and files from a message object
+def extract_input_and_files(message):  # Extract input and files from message
+    """
+    Extracts the input text and any attached files from the message object.
+    Returns a tuple (input, files).
+    """
+    input = ""  # Initialize input as empty string
+    files = None  # Initialize files as None
+
+    # Check if the message is a dictionary which may contain both text and file attachments
+    if isinstance(message, dict):  # If message is a dictionary
+        input = message.get("text", "")  # Get text from message dictionary
+        files = message.get("files")[0] if message.get("files") else None  # Get first file if present
+    else:  # If message is a simple string
+        input = message  # Assign message directly to input
+
+    return input, files  # Return extracted input and files