ai: Restructured repo for production.

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -4,7 +4,7 @@ colorFrom: yellow
 colorTo: purple
 sdk: gradio
 sdk_version: 5.29.0
-app_file: jarvis.py
+app_file: app.py
 pinned: true
 short_description: Inspired by Iron Man movies.
 models:

app.py

@@ -0,0 +1,10 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+from src.main.gradio import launch_ui
+
+# J.A.R.V.I.S.
+if __name__ == "__main__":
+    launch_ui()

API.md → docs/API.md

@@ -10,7 +10,7 @@ pip install gradio_client rich --upgrade
 #### DOWNLOAD JARVIS SCRIPT
 ```bash
 # Terminal script.
-wget https://huggingface.co/spaces/hadadrjt/ai/raw/main/ai
+wget https://huggingface.co/spaces/hadadrjt/ai/raw/main/assets/bin/ai
 
 # Set permission.
 chmod a+x ai

jarvis.py

@@ -1,573 +0,0 @@
-#
-# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
-# SPDX-License-Identifier: Apache-2.0
-#
-
-import asyncio
-import codecs # Reasoning
-import docx # Microsoft Word
-import gradio as gr
-import httpx
-import json
-import os
-import pandas as pd # Microsoft Excel
-import pdfplumber # PDF
-import pytesseract # OCR
-import random
-import requests
-import threading
-import uuid
-import zipfile # Microsoft Word
-import io
-
-from PIL import Image # OCR
-from pathlib import Path
-from pptx import Presentation # Microsoft PowerPoint
-from openpyxl import load_workbook # Microsoft Excel
-
-# ============================
-# System Setup
-# ============================
-
-# Install Tesseract OCR and dependencies for text extraction from images.
-os.system("apt-get update -q -y && \
-           apt-get install -q -y tesseract-ocr \
-           tesseract-ocr-eng tesseract-ocr-ind \
-           libleptonica-dev libtesseract-dev"
-)
-
-# ============================
-# HF Secrets Setup
-# ============================
-
-# Initial welcome messages
-JARVIS_INIT = json.loads(os.getenv("HELLO", "[]"))
-
-# Deep Search
-DEEP_SEARCH_PROVIDER_HOST = os.getenv("DEEP_SEARCH_PROVIDER_HOST")
-DEEP_SEARCH_PROVIDER_KEY = os.getenv('DEEP_SEARCH_PROVIDER_KEY')
-DEEP_SEARCH_INSTRUCTIONS = os.getenv("DEEP_SEARCH_INSTRUCTIONS")
-
-# Servers and instructions
-INTERNAL_AI_GET_SERVER = os.getenv("INTERNAL_AI_GET_SERVER")
-INTERNAL_AI_INSTRUCTIONS = os.getenv("INTERNAL_TRAINING_DATA")
-
-# System instructions mapping
-SYSTEM_PROMPT_MAPPING = json.loads(os.getenv("SYSTEM_PROMPT_MAPPING", "{}"))
-SYSTEM_PROMPT_DEFAULT = os.getenv("DEFAULT_SYSTEM")
-
-# List of available servers
-LINUX_SERVER_HOSTS = [h for h in json.loads(os.getenv("LINUX_SERVER_HOST", "[]")) if h]
-
-# List of available keys
-LINUX_SERVER_PROVIDER_KEYS = [k for k in json.loads(os.getenv("LINUX_SERVER_PROVIDER_KEY", "[]")) if k]
-LINUX_SERVER_PROVIDER_KEYS_MARKED = set()
-LINUX_SERVER_PROVIDER_KEYS_ATTEMPTS = {}
-
-# Server errors codes
-LINUX_SERVER_ERRORS = set(map(int, filter(None, os.getenv("LINUX_SERVER_ERROR", "").split(","))))
-
-# Personal UI
-AI_TYPES = {f"AI_TYPE_{i}": os.getenv(f"AI_TYPE_{i}") for i in range(1, 10)}
-RESPONSES = {f"RESPONSE_{i}": os.getenv(f"RESPONSE_{i}") for i in range(1, 11)}
-
-# Model mapping
-MODEL_MAPPING = json.loads(os.getenv("MODEL_MAPPING", "{}"))
-MODEL_CONFIG = json.loads(os.getenv("MODEL_CONFIG", "{}"))
-MODEL_CHOICES = list(MODEL_MAPPING.values())
-
-# Default model config and key for fallback
-DEFAULT_CONFIG = json.loads(os.getenv("DEFAULT_CONFIG", "{}"))
-DEFAULT_MODEL_KEY = list(MODEL_MAPPING.keys())[0] if MODEL_MAPPING else None
-
-# HTML <head> codes (SEO, etc.)
-META_TAGS = os.getenv("META_TAGS")
-
-# Allowed file extensions
-ALLOWED_EXTENSIONS = json.loads(os.getenv("ALLOWED_EXTENSIONS", "[]"))
-
-# ============================
-# Session Management
-# ============================
-
-class SessionWithID(requests.Session):
-    """
-    Custom session object that holds a unique session ID and async control flags.
-    Used to track individual user sessions and allow cancellation of ongoing requests.
-    """
-    def __init__(self):
-        super().__init__()
-        self.session_id = str(uuid.uuid4())  # Unique ID per session
-        self.stop_event = asyncio.Event()    # Async event to signal stop requests
-        self.cancel_token = {"cancelled": False}  # Flag to indicate cancellation
-
-def create_session():
-    """
-    Create and return a new SessionWithID object.
-    Called when a new user session starts or chat is reset.
-    """
-    return SessionWithID()
-
-def ensure_stop_event(sess):
-    """
-    Ensure that the session object has stop_event and cancel_token attributes.
-    Useful when restoring or reusing sessions.
-    """
-    if not hasattr(sess, "stop_event"):
-        sess.stop_event = asyncio.Event()
-    if not hasattr(sess, "cancel_token"):
-        sess.cancel_token = {"cancelled": False}
-
-def marked_item(item, marked, attempts):
-    """
-    Mark a provider key or host as temporarily problematic after repeated failures.
-    Automatically unmark after 5 minutes to retry.
-    This helps avoid repeatedly using failing providers.
-    """
-    marked.add(item)
-    attempts[item] = attempts.get(item, 0) + 1
-    if attempts[item] >= 3:
-        def remove():
-            marked.discard(item)
-            attempts.pop(item, None)
-        threading.Timer(300, remove).start()
-
-def get_model_key(display):
-    """
-    Get the internal model key (identifier) from the display name.
-    Returns default model key if not found.
-    """
-    return next((k for k, v in MODEL_MAPPING.items() if v == display), DEFAULT_MODEL_KEY)
-
-# ============================
-# File Content Extraction Utilities
-# ============================
-
-def extract_pdf_content(fp):
-    """
-    Extract text content from PDF file.
-    Includes OCR on embedded images to capture text within images.
-    Also extracts tables as tab-separated text.
-    """
-    content = ""
-    try:
-        with pdfplumber.open(fp) as pdf:
-            for page in pdf.pages:
-                # Extract text from page
-                text = page.extract_text() or ""
-                content += text + "\n"
-                # OCR on images if any
-                if page.images:
-                    img_obj = page.to_image(resolution=300)
-                    for img in page.images:
-                        bbox = (img["x0"], img["top"], img["x1"], img["bottom"])
-                        cropped = img_obj.original.crop(bbox)
-                        ocr_text = pytesseract.image_to_string(cropped)
-                        if ocr_text.strip():
-                            content += ocr_text + "\n"
-                # Extract tables as TSV
-                tables = page.extract_tables()
-                for table in tables:
-                    for row in table:
-                        cells = [str(cell) for cell in row if cell is not None]
-                        if cells:
-                            content += "\t".join(cells) + "\n"
-    except Exception as e:
-        content += f"\n[Error reading PDF {fp}: {e}]"
-    return content.strip()
-
-def extract_docx_content(fp):
-    """
-    Extract text from Microsoft Word files.
-    Also performs OCR on embedded images inside the Microsoft Word archive.
-    """
-    content = ""
-    try:
-        doc = docx.Document(fp)
-        # Extract paragraphs
-        for para in doc.paragraphs:
-            content += para.text + "\n"
-        # Extract tables
-        for table in doc.tables:
-            for row in table.rows:
-                cells = [cell.text for cell in row.cells]
-                content += "\t".join(cells) + "\n"
-        # OCR on embedded images inside Microsoft Word
-        with zipfile.ZipFile(fp) as z:
-            for file in z.namelist():
-                if file.startswith("word/media/"):
-                    data = z.read(file)
-                    try:
-                        img = Image.open(io.BytesIO(data))
-                        ocr_text = pytesseract.image_to_string(img)
-                        if ocr_text.strip():
-                            content += ocr_text + "\n"
-                    except Exception:
-                        # Ignore images that can't be processed
-                        pass
-    except Exception as e:
-        content += f"\n[Error reading Microsoft Word {fp}: {e}]"
-    return content.strip()
-
-def extract_excel_content(fp):
-    """
-    Extract content from Microsoft Excel files.
-    Converts sheets to CSV text.
-    Attempts OCR on embedded images if present.
-    """
-    content = ""
-    try:
-        # Extract all sheets as CSV text
-        sheets = pd.read_excel(fp, sheet_name=None)
-        for name, df in sheets.items():
-            content += f"Sheet: {name}\n"
-            content += df.to_csv(index=False) + "\n"
-        # Load workbook to access images
-        wb = load_workbook(fp, data_only=True)
-        if wb._images:
-            for image in wb._images:
-                try:
-                    pil_img = Image.open(io.BytesIO(image._data()))
-                    ocr_text = pytesseract.image_to_string(pil_img)
-                    if ocr_text.strip():
-                        content += ocr_text + "\n"
-                except Exception:
-                    # Ignore images that can't be processed
-                    pass
-    except Exception as e:
-        content += f"\n[Error reading Microsoft Excel {fp}: {e}]"
-    return content.strip()
-
-def extract_pptx_content(fp):
-    """
-    Extract text content from Microsoft PowerPoint presentation slides.
-    Includes text from shapes and tables.
-    Performs OCR on embedded images.
-    """
-    content = ""
-    try:
-        prs = Presentation(fp)
-        for slide in prs.slides:
-            for shape in slide.shapes:
-                # Extract text from shapes
-                if hasattr(shape, "text") and shape.text:
-                    content += shape.text + "\n"
-                # OCR on images inside shapes
-                if shape.shape_type == 13 and hasattr(shape, "image") and shape.image:
-                    try:
-                        img = Image.open(io.BytesIO(shape.image.blob))
-                        ocr_text = pytesseract.image_to_string(img)
-                        if ocr_text.strip():
-                            content += ocr_text + "\n"
-                    except Exception:
-                        pass
-            # Extract tables
-            for shape in slide.shapes:
-                if shape.has_table:
-                    table = shape.table
-                    for row in table.rows:
-                        cells = [cell.text for cell in row.cells]
-                        content += "\t".join(cells) + "\n"
-    except Exception as e:
-        content += f"\n[Error reading Microsoft PowerPoint {fp}: {e}]"
-    return content.strip()
-
-def extract_file_content(fp):
-    """
-    Determine file type by extension and extract text content accordingly.
-    For unknown types, attempts to read as plain text.
-    """
-    ext = Path(fp).suffix.lower()
-    if ext == ".pdf":
-        return extract_pdf_content(fp)
-    elif ext in [".doc", ".docx"]:
-        return extract_docx_content(fp)
-    elif ext in [".xlsx", ".xls"]:
-        return extract_excel_content(fp)
-    elif ext in [".ppt", ".pptx"]:
-        return extract_pptx_content(fp)
-    else:
-        try:
-            return Path(fp).read_text(encoding="utf-8").strip()
-        except Exception as e:
-            return f"\n[Error reading file {fp}: {e}]"
-
-# ============================
-# AI Server Communication
-# ============================
-
-async def fetch_response_stream_async(host, key, model, msgs, cfg, sid, stop_event, cancel_token):
-    """
-    Async generator that streams AI responses from a backend server.
-    Implements retry logic and marks failing keys to avoid repeated failures.
-    Streams reasoning and content separately for richer UI updates.
-    """
-    for timeout in [5, 10]:
-        try:
-            async with httpx.AsyncClient(timeout=timeout) as client:
-                async with client.stream("POST", host, json={**{"model": model, "messages": msgs, "session_id": sid, "stream": True}, **cfg}, headers={"Authorization": f"Bearer {key}"}) as response:
-                    if response.status_code in LINUX_SERVER_ERRORS:
-                        marked_item(key, LINUX_SERVER_PROVIDER_KEYS_MARKED, LINUX_SERVER_PROVIDER_KEYS_ATTEMPTS)
-                        return
-                    async for line in response.aiter_lines():
-                        if stop_event.is_set() or cancel_token["cancelled"]:
-                            return
-                        if not line:
-                            continue
-                        if line.startswith("data: "):
-                            data = line[6:]
-                            if data.strip() == RESPONSES["RESPONSE_10"]:
-                                return
-                            try:
-                                j = json.loads(data)
-                                if isinstance(j, dict) and j.get("choices"):
-                                    for ch in j["choices"]:
-                                        delta = ch.get("delta", {})
-                                        # Stream reasoning text separately for UI
-                                        if "reasoning" in delta and delta["reasoning"]:
-                                            decoded = delta["reasoning"].encode('utf-8').decode('unicode_escape')
-                                            yield ("reasoning", decoded)
-                                        # Stream main content text
-                                        if "content" in delta and delta["content"]:
-                                            yield ("content", delta["content"])
-                            except Exception:
-                                # Ignore malformed JSON or unexpected data
-                                continue
-        except Exception:
-            # Network or other errors, try next timeout or mark key
-            continue
-        marked_item(key, LINUX_SERVER_PROVIDER_KEYS_MARKED, LINUX_SERVER_PROVIDER_KEYS_ATTEMPTS)
-    return
-
-async def chat_with_model_async(history, user_input, model_display, sess, custom_prompt, deep_search):
-    """
-    Core async function to interact with AI model.
-    Prepares message history, system instructions, and optionally integrates deep search results.
-    Tries multiple backend hosts and keys with fallback.
-    Yields streamed responses for UI updates.
-    """
-    ensure_stop_event(sess)
-    sess.stop_event.clear()
-    sess.cancel_token["cancelled"] = False
-    if not LINUX_SERVER_PROVIDER_KEYS or not LINUX_SERVER_HOSTS:
-        yield ("content", RESPONSES["RESPONSE_3"])  # No providers available
-        return
-    if not hasattr(sess, "session_id") or not sess.session_id:
-        sess.session_id = str(uuid.uuid4())
-    model_key = get_model_key(model_display)
-    cfg = MODEL_CONFIG.get(model_key, DEFAULT_CONFIG)
-    msgs = []
-    # If deep search enabled and using primary model, prepend deep search instructions and results
-    if deep_search and model_display == MODEL_CHOICES[0]:
-        msgs.append({"role": "system", "content": DEEP_SEARCH_INSTRUCTIONS})
-        try:
-            async with httpx.AsyncClient() as client:
-                payload = {
-                    "query": user_input,
-                    "topic": "general",
-                    "search_depth": "basic",
-                    "chunks_per_source": 5,
-                    "max_results": 5,
-                    "time_range": None,
-                    "days": 7,
-                    "include_answer": True,
-                    "include_raw_content": False,
-                    "include_images": False,
-                    "include_image_descriptions": False,
-                    "include_domains": [],
-                    "exclude_domains": []
-                }
-                r = await client.post(DEEP_SEARCH_PROVIDER_HOST, headers={"Authorization": f"Bearer {DEEP_SEARCH_PROVIDER_KEY}"}, json=payload)
-                sr_json = r.json()
-                msgs.append({"role": "system", "content": json.dumps(sr_json)})
-        except Exception:
-            # Fail silently if deep search fails
-            pass
-        msgs.append({"role": "system", "content": INTERNAL_AI_INSTRUCTIONS})
-    elif model_display == MODEL_CHOICES[0]:
-        # For primary model without deep search, use internal instructions
-        msgs.append({"role": "system", "content": INTERNAL_AI_INSTRUCTIONS})
-    else:
-        # For other models, use default instructions
-        msgs.append({"role": "system", "content": custom_prompt or SYSTEM_PROMPT_MAPPING.get(model_key, SYSTEM_PROMPT_DEFAULT)})
-    # Append conversation history alternating user and assistant messages
-    msgs.extend([{"role": "user", "content": u} for u, _ in history])
-    msgs.extend([{"role": "assistant", "content": a} for _, a in history if a])
-    # Append current user input
-    msgs.append({"role": "user", "content": user_input})
-    # Shuffle provider hosts and keys for load balancing and fallback
-    candidates = [(h, k) for h in LINUX_SERVER_HOSTS for k in LINUX_SERVER_PROVIDER_KEYS]
-    random.shuffle(candidates)
-    # Try each host-key pair until a successful response is received
-    for h, k in candidates:
-        stream_gen = fetch_response_stream_async(h, k, model_key, msgs, cfg, sess.session_id, sess.stop_event, sess.cancel_token)
-        got_responses = False
-        async for chunk in stream_gen:
-            if sess.stop_event.is_set() or sess.cancel_token["cancelled"]:
-                return
-            got_responses = True
-            yield chunk
-        if got_responses:
-            return
-    # If no response from any provider, yield fallback message
-    yield ("content", RESPONSES["RESPONSE_2"])
-
-# ============================
-# Gradio Interaction Handlers
-# ============================
-
-async def respond_async(multi, history, model_display, sess, custom_prompt, deep_search):
-    """
-    Main async handler for user input submission.
-    Supports text + file uploads (multi-modal input).
-    Extracts file content and appends to user input.
-    Streams AI responses back to UI, updating chat history live.
-    Allows stopping response generation gracefully.
-    """
-    ensure_stop_event(sess)
-    sess.stop_event.clear()
-    sess.cancel_token["cancelled"] = False
-    # Extract text and files from multimodal input
-    msg_input = {"text": multi.get("text", "").strip(), "files": multi.get("files", [])}
-    # If no input, reset UI state and return
-    if not msg_input["text"] and not msg_input["files"]:
-        yield history, gr.update(value="", interactive=True, submit_btn=True, stop_btn=False), sess
-        return
-    # Initialize input with extracted file contents
-    inp = ""
-    for f in msg_input["files"]:
-        # Support dict or direct file path
-        fp = f.get("data", f.get("name", "")) if isinstance(f, dict) else f
-        inp += f"{Path(fp).name}\n\n{extract_file_content(fp)}\n\n"
-    # Append user text input if any
-    if msg_input["text"]:
-        inp += msg_input["text"]
-    # Append user input to chat history with placeholder response
-    history.append([inp, RESPONSES["RESPONSE_8"]])
-    yield history, gr.update(interactive=False, submit_btn=False, stop_btn=True), sess
-    queue = asyncio.Queue()
-    # Background async task to fetch streamed AI responses
-    async def background():
-        reasoning = ""
-        responses = ""
-        content_started = False
-        ignore_reasoning = False
-        async for typ, chunk in chat_with_model_async(history, inp, model_display, sess, custom_prompt, deep_search):
-            if sess.stop_event.is_set() or sess.cancel_token["cancelled"]:
-                break
-            if typ == "reasoning":
-                if ignore_reasoning:
-                    continue
-                reasoning += chunk
-                await queue.put(("reasoning", reasoning))
-            elif typ == "content":
-                if not content_started:
-                    content_started = True
-                    ignore_reasoning = True
-                    responses = chunk
-                    await queue.put(("reasoning", ""))  # Clear reasoning on content start
-                    await queue.put(("replace", responses))
-                else:
-                    responses += chunk
-                    await queue.put(("append", responses))
-        await queue.put(None)
-        return responses
-    bg_task = asyncio.create_task(background())
-    stop_task = asyncio.create_task(sess.stop_event.wait())
-    pending_tasks = {bg_task, stop_task}
-    try:
-        while True:
-            queue_task = asyncio.create_task(queue.get())
-            pending_tasks.add(queue_task)
-            done, _ = await asyncio.wait({stop_task, queue_task}, return_when=asyncio.FIRST_COMPLETED)
-            for task in done:
-                pending_tasks.discard(task)
-                if task is stop_task:
-                    # User requested stop, cancel background task and update UI
-                    sess.cancel_token["cancelled"] = True
-                    bg_task.cancel()
-                    try:
-                        await bg_task
-                    except asyncio.CancelledError:
-                        pass
-                    history[-1][1] = RESPONSES["RESPONSE_1"]
-                    yield history, gr.update(value="", interactive=True, submit_btn=True, stop_btn=False), sess
-                    return
-                result = task.result()
-                if result is None:
-                    raise StopAsyncIteration
-                action, text = result
-                # Update last message content in history with streamed text
-                history[-1][1] = text
-                yield history, gr.update(interactive=False, submit_btn=False, stop_btn=True), sess
-    except StopAsyncIteration:
-        pass
-    finally:
-        for task in pending_tasks:
-            task.cancel()
-        await asyncio.gather(*pending_tasks, return_exceptions=True)
-    yield history, gr.update(value="", interactive=True, submit_btn=True, stop_btn=False), sess
-
-def toggle_deep_search(deep_search_value, history, sess, prompt, model):
-    """
-    Toggle deep search checkbox. Keeps chat intact for production compatibility.
-    """
-    return history, sess, prompt, model, gr.update(value=deep_search_value)
-
-def change_model(new):
-    """
-    Handler to change selected AI model.
-    Resets chat history and session.
-    Updates system instructions and deep search checkbox visibility accordingly.
-    Deep search is only available for default model.
-    """
-    visible = new == MODEL_CHOICES[0]
-    default_prompt = SYSTEM_PROMPT_MAPPING.get(get_model_key(new), SYSTEM_PROMPT_DEFAULT)
-    # On model change, clear chat, create new session, reset deep search, update visibility
-    return [], create_session(), new, default_prompt, False, gr.update(visible=visible)
-
-def stop_response(history, sess):
-    """
-    Handler to stop ongoing AI response generation.
-    Sets cancellation flags and updates last message to cancellation notice.
-    """
-    ensure_stop_event(sess)
-    sess.stop_event.set()
-    sess.cancel_token["cancelled"] = True
-    if history:
-        history[-1][1] = RESPONSES["RESPONSE_1"]
-    return history, None, create_session()
-
-# ============================
-# Gradio UI Setup
-# ============================
-
-with gr.Blocks(fill_height=True, fill_width=True, title=AI_TYPES["AI_TYPE_4"], head=META_TAGS) as jarvis:
-    user_history = gr.State([])
-    user_session = gr.State(create_session())
-    selected_model = gr.State(MODEL_CHOICES[0] if MODEL_CHOICES else "")
-    J_A_R_V_I_S = gr.State("")
-    # Chatbot UI
-    chatbot = gr.Chatbot(label=AI_TYPES["AI_TYPE_1"], show_copy_button=True, scale=1, elem_id=AI_TYPES["AI_TYPE_2"], examples=JARVIS_INIT)
-    # Deep search
-    deep_search = gr.Checkbox(label=AI_TYPES["AI_TYPE_8"], value=False, info=AI_TYPES["AI_TYPE_9"], visible=True)
-    deep_search.change(fn=toggle_deep_search, inputs=[deep_search, user_history, user_session, J_A_R_V_I_S, selected_model], outputs=[chatbot, user_session, J_A_R_V_I_S, selected_model, deep_search])
-    # User's input
-    msg = gr.MultimodalTextbox(show_label=False, placeholder=RESPONSES["RESPONSE_5"], interactive=True, file_count="single", file_types=ALLOWED_EXTENSIONS)
-    # Sidebar to select AI models
-    with gr.Sidebar(open=False): model_radio = gr.Radio(show_label=False, choices=MODEL_CHOICES, value=MODEL_CHOICES[0])
-    # Models change
-    model_radio.change(fn=change_model, inputs=[model_radio], outputs=[user_history, user_session, selected_model, J_A_R_V_I_S, deep_search, deep_search])
-    # Initial welcome messages
-    def on_example_select(evt: gr.SelectData): return evt.value
-    chatbot.example_select(fn=on_example_select, inputs=[], outputs=[msg]).then(fn=respond_async, inputs=[msg, user_history, selected_model, user_session, J_A_R_V_I_S, deep_search], outputs=[chatbot, msg, user_session])
-    # Clear chat
-    def clear_chat(history, sess, prompt, model): return [], create_session(), prompt, model
-    chatbot.clear(fn=clear_chat, inputs=[user_history, user_session, J_A_R_V_I_S, selected_model], outputs=[chatbot, user_session, J_A_R_V_I_S, selected_model])
-    # Submit message
-    msg.submit(fn=respond_async, inputs=[msg, user_history, selected_model, user_session, J_A_R_V_I_S, deep_search], outputs=[chatbot, msg, user_session], api_name=INTERNAL_AI_GET_SERVER)
-    # Stop message
-    msg.stop(fn=stop_response, inputs=[user_history, user_session], outputs=[chatbot, msg, user_session])
-
-# Launch
-jarvis.queue(default_concurrency_limit=2).launch(max_file_size="1mb")

src/config.py

@@ -0,0 +1,53 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import os
+import json
+
+# Initial welcome messages
+JARVIS_INIT = json.loads(os.getenv("HELLO", "[]"))
+
+# Deep Search
+DEEP_SEARCH_PROVIDER_HOST = os.getenv("DEEP_SEARCH_PROVIDER_HOST")
+DEEP_SEARCH_PROVIDER_KEY = os.getenv('DEEP_SEARCH_PROVIDER_KEY')
+DEEP_SEARCH_INSTRUCTIONS = os.getenv("DEEP_SEARCH_INSTRUCTIONS")
+
+# Servers and instructions
+INTERNAL_AI_GET_SERVER = os.getenv("INTERNAL_AI_GET_SERVER")
+INTERNAL_AI_INSTRUCTIONS = os.getenv("INTERNAL_TRAINING_DATA")
+
+# System instructions mapping
+SYSTEM_PROMPT_MAPPING = json.loads(os.getenv("SYSTEM_PROMPT_MAPPING", "{}"))
+SYSTEM_PROMPT_DEFAULT = os.getenv("DEFAULT_SYSTEM")
+
+# List of available servers
+LINUX_SERVER_HOSTS = [h for h in json.loads(os.getenv("LINUX_SERVER_HOST", "[]")) if h]
+
+# List of available keys
+LINUX_SERVER_PROVIDER_KEYS = [k for k in json.loads(os.getenv("LINUX_SERVER_PROVIDER_KEY", "[]")) if k]
+LINUX_SERVER_PROVIDER_KEYS_MARKED = set()
+LINUX_SERVER_PROVIDER_KEYS_ATTEMPTS = {}
+
+# Server errors codes
+LINUX_SERVER_ERRORS = set(map(int, filter(None, os.getenv("LINUX_SERVER_ERROR", "").split(","))))
+
+# Human friendly AI setup
+AI_TYPES = {f"AI_TYPE_{i}": os.getenv(f"AI_TYPE_{i}") for i in range(1, 10)}
+RESPONSES = {f"RESPONSE_{i}": os.getenv(f"RESPONSE_{i}") for i in range(1, 11)}
+
+# Model mapping
+MODEL_MAPPING = json.loads(os.getenv("MODEL_MAPPING", "{}"))
+MODEL_CONFIG = json.loads(os.getenv("MODEL_CONFIG", "{}"))
+MODEL_CHOICES = list(MODEL_MAPPING.values())
+
+# Default model config and key for fallback
+DEFAULT_CONFIG = json.loads(os.getenv("DEFAULT_CONFIG", "{}"))
+DEFAULT_MODEL_KEY = list(MODEL_MAPPING.keys())[0] if MODEL_MAPPING else None
+
+# HTML <head> codes (SEO, etc.)
+META_TAGS = os.getenv("META_TAGS")
+
+# Allowed file extensions
+ALLOWED_EXTENSIONS = json.loads(os.getenv("ALLOWED_EXTENSIONS", "[]"))

src/cores/client.py

@@ -0,0 +1,87 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import asyncio
+import httpx
+import json
+import random
+import uuid
+
+from src.config import *
+from src.cores.server import fetch_response_stream_async
+from src.cores.session import ensure_stop_event, get_model_key
+
+async def chat_with_model_async(history, user_input, model_display, sess, custom_prompt, deep_search):
+    """
+    Core async function to interact with AI model.
+    Prepares message history, system instructions, and optionally integrates deep search results.
+    Tries multiple backend hosts and keys with fallback.
+    Yields streamed responses for UI updates.
+    """
+    ensure_stop_event(sess)
+    sess.stop_event.clear()
+    sess.cancel_token["cancelled"] = False
+    if not LINUX_SERVER_PROVIDER_KEYS or not LINUX_SERVER_HOSTS:
+        yield ("content", RESPONSES["RESPONSE_3"])  # No providers available
+        return
+    if not hasattr(sess, "session_id") or not sess.session_id:
+        sess.session_id = str(uuid.uuid4())
+    model_key = get_model_key(model_display, MODEL_MAPPING, DEFAULT_MODEL_KEY)
+    cfg = MODEL_CONFIG.get(model_key, DEFAULT_CONFIG)
+    msgs = []
+    # If deep search enabled and using primary model, prepend deep search instructions and results
+    if deep_search and model_display == MODEL_CHOICES[0]:
+        msgs.append({"role": "system", "content": DEEP_SEARCH_INSTRUCTIONS})
+        try:
+            async with httpx.AsyncClient() as client:
+                payload = {
+                    "query": user_input,
+                    "topic": "general",
+                    "search_depth": "basic",
+                    "chunks_per_source": 5,
+                    "max_results": 5,
+                    "time_range": None,
+                    "days": 7,
+                    "include_answer": True,
+                    "include_raw_content": False,
+                    "include_images": False,
+                    "include_image_descriptions": False,
+                    "include_domains": [],
+                    "exclude_domains": []
+                }
+                r = await client.post(DEEP_SEARCH_PROVIDER_HOST, headers={"Authorization": f"Bearer {DEEP_SEARCH_PROVIDER_KEY}"}, json=payload)
+                sr_json = r.json()
+                msgs.append({"role": "system", "content": json.dumps(sr_json)})
+        except Exception:
+            # Fail silently if deep search fails
+            pass
+        msgs.append({"role": "system", "content": INTERNAL_AI_INSTRUCTIONS})
+    elif model_display == MODEL_CHOICES[0]:
+        # For primary model without deep search, use internal instructions
+        msgs.append({"role": "system", "content": INTERNAL_AI_INSTRUCTIONS})
+    else:
+        # For other models, use default instructions
+        msgs.append({"role": "system", "content": custom_prompt or SYSTEM_PROMPT_MAPPING.get(model_key, SYSTEM_PROMPT_DEFAULT)})
+    # Append conversation history alternating user and assistant messages
+    msgs.extend([{"role": "user", "content": u} for u, _ in history])
+    msgs.extend([{"role": "assistant", "content": a} for _, a in history if a])
+    # Append current user input
+    msgs.append({"role": "user", "content": user_input})
+    # Shuffle provider hosts and keys for load balancing and fallback
+    candidates = [(h, k) for h in LINUX_SERVER_HOSTS for k in LINUX_SERVER_PROVIDER_KEYS]
+    random.shuffle(candidates)
+    # Try each host-key pair until a successful response is received
+    for h, k in candidates:
+        stream_gen = fetch_response_stream_async(h, k, model_key, msgs, cfg, sess.session_id, sess.stop_event, sess.cancel_token)
+        got_responses = False
+        async for chunk in stream_gen:
+            if sess.stop_event.is_set() or sess.cancel_token["cancelled"]:
+                return
+            got_responses = True
+            yield chunk
+        if got_responses:
+            return
+    # If no response from any provider, yield fallback message
+    yield ("content", RESPONSES["RESPONSE_2"])

src/cores/server.py

@@ -0,0 +1,59 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import codecs # Reasoning
+import httpx
+import json
+
+from src.cores.session import marked_item
+from src.config import LINUX_SERVER_ERRORS, LINUX_SERVER_PROVIDER_KEYS_MARKED, LINUX_SERVER_PROVIDER_KEYS_ATTEMPTS, RESPONSES
+
+async def fetch_response_stream_async(host, key, model, msgs, cfg, sid, stop_event, cancel_token):
+    """
+    Async generator that streams AI responses from a backend server.
+    Implements retry logic and marks failing keys to avoid repeated failures.
+    Streams reasoning and content separately for richer UI updates.
+    """
+    for timeout in [5, 10]:
+        try:
+            async with httpx.AsyncClient(timeout=timeout) as client:
+                async with client.stream(
+                    "POST",
+                    host,
+                    json={**{"model": model, "messages": msgs, "session_id": sid, "stream": True}, **cfg},
+                    headers={"Authorization": f"Bearer {key}"}
+                ) as response:
+                    if response.status_code in LINUX_SERVER_ERRORS:
+                        marked_item(key, LINUX_SERVER_PROVIDER_KEYS_MARKED, LINUX_SERVER_PROVIDER_KEYS_ATTEMPTS)
+                        return
+                    async for line in response.aiter_lines():
+                        if stop_event.is_set() or cancel_token["cancelled"]:
+                            return
+                        if not line:
+                            continue
+                        if line.startswith("data: "):
+                            data = line[6:]
+                            if data.strip() == RESPONSES["RESPONSE_10"]:
+                                return
+                            try:
+                                j = json.loads(data)
+                                if isinstance(j, dict) and j.get("choices"):
+                                    for ch in j["choices"]:
+                                        delta = ch.get("delta", {})
+                                        # Stream reasoning text separately for UI
+                                        if "reasoning" in delta and delta["reasoning"]:
+                                            decoded = delta["reasoning"].encode('utf-8').decode('unicode_escape')
+                                            yield ("reasoning", decoded)
+                                        # Stream main content text
+                                        if "content" in delta and delta["content"]:
+                                            yield ("content", delta["content"])
+                            except Exception:
+                                # Ignore malformed JSON or unexpected data
+                                continue
+        except Exception:
+            # Network or other errors, try next timeout or mark key
+            continue
+        marked_item(key, LINUX_SERVER_PROVIDER_KEYS_MARKED, LINUX_SERVER_PROVIDER_KEYS_ATTEMPTS)
+    return

src/cores/session.py

@@ -0,0 +1,60 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import asyncio
+import requests
+import uuid
+import threading
+
+from src.config import LINUX_SERVER_PROVIDER_KEYS_MARKED, LINUX_SERVER_PROVIDER_KEYS_ATTEMPTS
+
+class SessionWithID(requests.Session):
+    """
+    Custom session object that holds a unique session ID and async control flags.
+    Used to track individual user sessions and allow cancellation of ongoing requests.
+    """
+    def __init__(self):
+        super().__init__()
+        self.session_id = str(uuid.uuid4())  # Unique ID per session
+        self.stop_event = asyncio.Event()    # Async event to signal stop requests
+        self.cancel_token = {"cancelled": False}  # Flag to indicate cancellation
+
+def create_session():
+    """
+    Create and return a new SessionWithID object.
+    Called when a new user session starts or chat is reset.
+    """
+    return SessionWithID()
+
+def ensure_stop_event(sess):
+    """
+    Ensure that the session object has stop_event and cancel_token attributes.
+    Useful when restoring or reusing sessions.
+    """
+    if not hasattr(sess, "stop_event"):
+        sess.stop_event = asyncio.Event()
+    if not hasattr(sess, "cancel_token"):
+        sess.cancel_token = {"cancelled": False}
+
+def marked_item(item, marked, attempts):
+    """
+    Mark a provider key or host as temporarily problematic after repeated failures.
+    Automatically unmark after 5 minutes to retry.
+    This helps avoid repeatedly using failing providers.
+    """
+    marked.add(item)
+    attempts[item] = attempts.get(item, 0) + 1
+    if attempts[item] >= 3:
+        def remove():
+            marked.discard(item)
+            attempts.pop(item, None)
+        threading.Timer(300, remove).start()
+
+def get_model_key(display, MODEL_MAPPING, DEFAULT_MODEL_KEY):
+    """
+    Get the internal model key (identifier) from the display name.
+    Returns default model key if not found.
+    """
+    return next((k for k, v in MODEL_MAPPING.items() if v == display), DEFAULT_MODEL_KEY)

src/main/file_extractors.py

@@ -0,0 +1,218 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import pdfplumber # PDF
+import pytesseract # OCR
+import docx # Microsoft Word
+import zipfile # Microsoft Word
+import io
+import pandas as pd # Microsoft Excel
+import warnings
+import re
+
+from openpyxl import load_workbook # Microsoft Excel
+from pptx import Presentation # Microsoft PowerPoint
+from PIL import Image, ImageEnhance, ImageFilter # OCR
+from pathlib import Path
+
+def clean_text(text):
+    """Clean and normalize extracted outputs."""
+    # Remove non-printable and special characters except common punctuation
+    text = re.sub(r'[^a-zA-Z0-9\s.,?!():;\'"-]', '', text)
+    # Remove isolated single letters (likely OCR noise)
+    text = re.sub(r'\b[a-zA-Z]\b', '', text)
+    # Normalize whitespace and remove empty lines
+    lines = [line.strip() for line in text.splitlines() if line.strip()]
+    return "\n".join(lines)
+
+def format_table(df, max_rows=10):
+    """Format pandas DataFrame as a readable table string, limited to max rows."""
+    if df.empty:
+        return ""
+    # Drop fully empty rows and columns to reduce NaN clutter
+    df_clean = df.dropna(axis=0, how='all').dropna(axis=1, how='all')
+    # Replace NaN with empty string to avoid 'NaN' in output
+    df_clean = df_clean.fillna('')
+    if df_clean.empty:
+        return ""
+    display_df = df_clean.head(max_rows)
+    table_str = display_df.to_string(index=False)
+    if len(df_clean) > max_rows:
+        table_str += f"\n... ({len(df_clean) - max_rows} more rows)"
+    return table_str
+
+def preprocess_image(img):
+    """Preprocess image for better OCR accuracy."""
+    try:
+        img = img.convert("L")  # Grayscale
+        enhancer = ImageEnhance.Contrast(img)
+        img = enhancer.enhance(2)  # Increase contrast
+        img = img.filter(ImageFilter.MedianFilter())  # Reduce noise
+        # Binarize image (threshold)
+        img = img.point(lambda x: 0 if x < 140 else 255, '1')
+        return img
+    except Exception:
+        return img
+
+def ocr_image(img):
+    """Perform OCR on PIL Image with preprocessing and clean result."""
+    try:
+        img = preprocess_image(img)
+        text = pytesseract.image_to_string(img, lang='eng', config='--psm 6')
+        text = clean_text(text)
+        return text
+    except Exception:
+        return ""
+
+def extract_pdf_content(fp):
+    """
+    Extract text content from PDF file.
+    Includes OCR on embedded images to capture text within images.
+    Also extracts tables as tab-separated text.
+    """
+    content = ""
+    try:
+        with pdfplumber.open(fp) as pdf:
+            for i, page in enumerate(pdf.pages, 1):
+                text = page.extract_text() or ""
+                content += f"Page {i} Text:\n{clean_text(text)}\n\n"
+                # OCR on images if any
+                if page.images:
+                    img_obj = page.to_image(resolution=300)
+                    for img in page.images:
+                        bbox = (img["x0"], img["top"], img["x1"], img["bottom"])
+                        cropped = img_obj.original.crop(bbox)
+                        ocr_text = ocr_image(cropped)
+                        if ocr_text:
+                            content += f"[OCR Text from image on page {i}]:\n{ocr_text}\n\n"
+                # Extract tables as TSV
+                tables = page.extract_tables()
+                for idx, table in enumerate(tables, 1):
+                    if table:
+                        df = pd.DataFrame(table[1:], columns=table[0])
+                        content += f"Table {idx} on page {i}:\n{format_table(df)}\n\n"
+    except Exception as e:
+        content += f"\n[Error reading PDF {fp}: {e}]"
+    return content.strip()
+
+def extract_docx_content(fp):
+    """
+    Extract text from Microsoft Word files.
+    Also performs OCR on embedded images inside the Microsoft Word archive.
+    """
+    content = ""
+    try:
+        doc = docx.Document(fp)
+        paragraphs = [para.text.strip() for para in doc.paragraphs if para.text.strip()]
+        if paragraphs:
+            content += "Paragraphs:\n" + "\n".join(paragraphs) + "\n\n"
+        # Extract tables
+        tables = []
+        for table in doc.tables:
+            rows = []
+            for row in table.rows:
+                cells = [cell.text.strip() for cell in row.cells]
+                rows.append(cells)
+            if rows:
+                df = pd.DataFrame(rows[1:], columns=rows[0])
+                tables.append(df)
+        for i, df in enumerate(tables, 1):
+            content += f"Table {i}:\n{format_table(df)}\n\n"
+        # OCR on embedded images inside Microsoft Word
+        with zipfile.ZipFile(fp) as z:
+            for file in z.namelist():
+                if file.startswith("word/media/"):
+                    data = z.read(file)
+                    try:
+                        img = Image.open(io.BytesIO(data))
+                        ocr_text = ocr_image(img)
+                        if ocr_text:
+                            content += f"[OCR Text from embedded image]:\n{ocr_text}\n\n"
+                    except Exception:
+                        pass
+    except Exception as e:
+        content += f"\n[Error reading Microsoft Word {fp}: {e}]"
+    return content.strip()
+
+def extract_excel_content(fp):
+    """
+    Extract content from Microsoft Excel files.
+    Converts sheets to readable tables and replaces NaN values.
+    Does NOT attempt to extract images to avoid errors.
+    """
+    content = ""
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore") # Suppress openpyxl warnings
+            # Explicitly specify the engine to avoid potential issues
+            sheets = pd.read_excel(fp, sheet_name=None, engine='openpyxl')
+        for sheet_name, df in sheets.items():
+            content += f"Sheet: {sheet_name}\n"
+            content += format_table(df) + "\n\n"
+    except Exception as e:
+        content += f"\n[Error reading Microsoft Excel {fp}: {e}]"
+    return content.strip()
+
+def extract_pptx_content(fp):
+    """
+    Extract text content from Microsoft PowerPoint presentation slides.
+    Includes text from shapes and tables.
+    Performs OCR on embedded images.
+    """
+    content = ""
+    try:
+        prs = Presentation(fp)
+        for i, slide in enumerate(prs.slides, 1):
+            slide_texts = []
+            for shape in slide.shapes:
+                if hasattr(shape, "text") and shape.text.strip():
+                    slide_texts.append(shape.text.strip())
+                if shape.shape_type == 13 and hasattr(shape, "image") and shape.image:
+                    try:
+                        img = Image.open(io.BytesIO(shape.image.blob))
+                        ocr_text = ocr_image(img)
+                        if ocr_text:
+                            slide_texts.append(f"[OCR Text from image]:\n{ocr_text}")
+                    except Exception:
+                        pass
+            if slide_texts:
+                content += f"Slide {i} Text:\n" + "\n".join(slide_texts) + "\n\n"
+            else:
+                content += f"Slide {i} Text:\nNo text found on this slide.\n\n"
+            # Extract tables
+            for shape in slide.shapes:
+                if shape.has_table:
+                    rows = []
+                    table = shape.table
+                    for row in table.rows:
+                        cells = [cell.text.strip() for cell in row.cells]
+                        rows.append(cells)
+                    if rows:
+                        df = pd.DataFrame(rows[1:], columns=rows[0])
+                        content += f"Table on slide {i}:\n{format_table(df)}\n\n"
+    except Exception as e:
+        content += f"\n[Error reading Microsoft PowerPoint {fp}: {e}]"
+    return content.strip()
+
+def extract_file_content(fp):
+    """
+    Determine file type by extension and extract text content accordingly.
+    For unknown types, attempts to read as plain text.
+    """
+    ext = Path(fp).suffix.lower()
+    if ext == ".pdf":
+        return extract_pdf_content(fp)
+    elif ext in [".doc", ".docx"]:
+        return extract_docx_content(fp)
+    elif ext in [".xlsx", ".xls"]:
+        return extract_excel_content(fp)
+    elif ext in [".ppt", ".pptx"]:
+        return extract_pptx_content(fp)
+    else:
+        try:
+            text = Path(fp).read_text(encoding="utf-8")
+            return clean_text(text)
+        except Exception as e:
+            return f"\n[Error reading file {fp}: {e}]"

src/main/gradio.py

@@ -0,0 +1,177 @@
+#
+# SPDX-FileCopyrightText: Hadad <hadad@linuxmail.org>
+# SPDX-License-Identifier: Apache-2.0
+#
+
+import gradio as gr
+import asyncio
+
+from pathlib import Path
+from src.config import *
+from src.cores.session import create_session, ensure_stop_event, get_model_key
+from src.main.file_extractors import extract_file_content
+from src.cores.client import chat_with_model_async
+
+async def respond_async(multi, history, model_display, sess, custom_prompt, deep_search):
+    """
+    Main async handler for user input submission.
+    Supports text + file uploads (multi-modal input).
+    Extracts file content and appends to user input.
+    Streams AI responses back to UI, updating chat history live.
+    Allows stopping response generation gracefully.
+    """
+    ensure_stop_event(sess)
+    sess.stop_event.clear()
+    sess.cancel_token["cancelled"] = False
+    # Extract text and files from multimodal input
+    msg_input = {"text": multi.get("text", "").strip(), "files": multi.get("files", [])}
+    # If no input, reset UI state and return
+    if not msg_input["text"] and not msg_input["files"]:
+        yield history, gr.update(value="", interactive=True, submit_btn=True, stop_btn=False), sess
+        return
+    # Initialize input with extracted file contents
+    inp = ""
+    for f in msg_input["files"]:
+        # Support dict or direct file path
+        fp = f.get("data", f.get("name", "")) if isinstance(f, dict) else f
+        inp += f"{Path(fp).name}\n\n{extract_file_content(fp)}\n\n"
+    # Append user text input if any
+    if msg_input["text"]:
+        inp += msg_input["text"]
+    # Append user input to chat history with placeholder response
+    history.append([inp, RESPONSES["RESPONSE_8"]])
+    yield history, gr.update(interactive=False, submit_btn=False, stop_btn=True), sess
+    queue = asyncio.Queue()
+    # Background async task to fetch streamed AI responses
+    async def background():
+        reasoning = ""
+        responses = ""
+        content_started = False
+        ignore_reasoning = False
+        async for typ, chunk in chat_with_model_async(history, inp, model_display, sess, custom_prompt, deep_search):
+            if sess.stop_event.is_set() or sess.cancel_token["cancelled"]:
+                break
+            if typ == "reasoning":
+                if ignore_reasoning:
+                    continue
+                reasoning += chunk
+                await queue.put(("reasoning", reasoning))
+            elif typ == "content":
+                if not content_started:
+                    content_started = True
+                    ignore_reasoning = True
+                    responses = chunk
+                    await queue.put(("reasoning", ""))  # Clear reasoning on content start
+                    await queue.put(("replace", responses))
+                else:
+                    responses += chunk
+                    await queue.put(("append", responses))
+        await queue.put(None)
+        return responses
+    bg_task = asyncio.create_task(background())
+    stop_task = asyncio.create_task(sess.stop_event.wait())
+    pending_tasks = {bg_task, stop_task}
+    try:
+        while True:
+            queue_task = asyncio.create_task(queue.get())
+            pending_tasks.add(queue_task)
+            done, _ = await asyncio.wait({stop_task, queue_task}, return_when=asyncio.FIRST_COMPLETED)
+            for task in done:
+                pending_tasks.discard(task)
+                if task is stop_task:
+                    # User requested stop, cancel background task and update UI
+                    sess.cancel_token["cancelled"] = True
+                    bg_task.cancel()
+                    try:
+                        await bg_task
+                    except asyncio.CancelledError:
+                        pass
+                    history[-1][1] = RESPONSES["RESPONSE_1"]
+                    yield history, gr.update(value="", interactive=True, submit_btn=True, stop_btn=False), sess
+                    return
+                result = task.result()
+                if result is None:
+                    raise StopAsyncIteration
+                action, text = result
+                # Update last message content in history with streamed text
+                history[-1][1] = text
+                yield history, gr.update(interactive=False, submit_btn=False, stop_btn=True), sess
+    except StopAsyncIteration:
+        pass
+    finally:
+        for task in pending_tasks:
+            task.cancel()
+        await asyncio.gather(*pending_tasks, return_exceptions=True)
+    yield history, gr.update(value="", interactive=True, submit_btn=True, stop_btn=False), sess
+
+def toggle_deep_search(deep_search_value, history, sess, prompt, model):
+    """
+    Toggle deep search checkbox. Keeps chat intact for production compatibility.
+    """
+    return history, sess, prompt, model, gr.update(value=deep_search_value)
+
+def change_model(new):
+    """
+    Handler to change selected AI model.
+    Resets chat history and session.
+    Updates system instructions and deep search checkbox visibility accordingly.
+    Deep search is only available for default model.
+    """
+    visible = new == MODEL_CHOICES[0]
+    default_prompt = SYSTEM_PROMPT_MAPPING.get(get_model_key(new, MODEL_MAPPING, DEFAULT_MODEL_KEY), SYSTEM_PROMPT_DEFAULT)
+    # On model change, clear chat, create new session, reset deep search, update visibility
+    return [], create_session(), new, default_prompt, False, gr.update(visible=visible)
+
+def stop_response(history, sess):
+    """
+    Handler to stop ongoing AI response generation.
+    Sets cancellation flags and updates last message to cancellation notice.
+    """
+    ensure_stop_event(sess)
+    sess.stop_event.set()
+    sess.cancel_token["cancelled"] = True
+    if history:
+        history[-1][1] = RESPONSES["RESPONSE_1"]
+    return history, None, create_session()
+
+def launch_ui():
+    # ============================
+    # System Setup
+    # ============================
+
+    # Install Tesseract OCR and dependencies for text extraction from images.
+    import os
+    os.system("apt-get update -q -y && \
+               apt-get install -q -y tesseract-ocr \
+               tesseract-ocr-eng tesseract-ocr-ind \
+               libleptonica-dev libtesseract-dev"
+    )
+
+    with gr.Blocks(fill_height=True, fill_width=True, title=AI_TYPES["AI_TYPE_4"], head=META_TAGS) as jarvis:
+        user_history = gr.State([])
+        user_session = gr.State(create_session())
+        selected_model = gr.State(MODEL_CHOICES[0] if MODEL_CHOICES else "")
+        J_A_R_V_I_S = gr.State("")
+        # Chatbot UI
+        with gr.Column(): chatbot = gr.Chatbot(label=AI_TYPES["AI_TYPE_1"], show_copy_button=True, scale=1, elem_id=AI_TYPES["AI_TYPE_2"], examples=JARVIS_INIT)
+        # Deep search
+        deep_search = gr.Checkbox(label=AI_TYPES["AI_TYPE_8"], value=False, info=AI_TYPES["AI_TYPE_9"], visible=True)
+        deep_search.change(fn=toggle_deep_search, inputs=[deep_search, user_history, user_session, J_A_R_V_I_S, selected_model], outputs=[chatbot, user_session, J_A_R_V_I_S, selected_model, deep_search])
+        # User's input
+        msg = gr.MultimodalTextbox(show_label=False, placeholder=RESPONSES["RESPONSE_5"], interactive=True, file_count="single", file_types=ALLOWED_EXTENSIONS)
+        # Sidebar to select AI models
+        with gr.Sidebar(open=False): model_radio = gr.Radio(show_label=False, choices=MODEL_CHOICES, value=MODEL_CHOICES[0])
+        # Models change
+        model_radio.change(fn=change_model, inputs=[model_radio], outputs=[user_history, user_session, selected_model, J_A_R_V_I_S, deep_search, deep_search])
+        # Initial welcome messages
+        def on_example_select(evt: gr.SelectData): return evt.value
+        chatbot.example_select(fn=on_example_select, inputs=[], outputs=[msg]).then(fn=respond_async, inputs=[msg, user_history, selected_model, user_session, J_A_R_V_I_S, deep_search], outputs=[chatbot, msg, user_session])
+        # Clear chat
+        def clear_chat(history, sess, prompt, model): return [], create_session(), prompt, model
+        chatbot.clear(fn=clear_chat, inputs=[user_history, user_session, J_A_R_V_I_S, selected_model], outputs=[chatbot, user_session, J_A_R_V_I_S, selected_model])
+        # Submit message
+        msg.submit(fn=respond_async, inputs=[msg, user_history, selected_model, user_session, J_A_R_V_I_S, deep_search], outputs=[chatbot, msg, user_session], api_name=INTERNAL_AI_GET_SERVER)
+        # Stop message
+        msg.stop(fn=stop_response, inputs=[user_history, user_session], outputs=[chatbot, msg, user_session])
+    # Launch
+    jarvis.queue(default_concurrency_limit=2).launch(max_file_size="1mb")