Update app.py

app.py

@@ -17,10 +17,9 @@ import easyocr
 from web_engine import search_info, get_page_text  # Импортируем функции из web_engine.py
 
 AVAILABLE_MODELS = {
-    "GPT-4": "gpt-4",
-    "GPT-4 Turbo": "gpt-4-turbo",
-    "GPT-4o": "gpt-4o",
-    "GPT-4o THINK": "gpt-4o-think"
+    # "GPT-4": "gpt-4",
+    "O3 (NEW)": "openai",
+
 }
  
 SYSTEM_PROMPT = """
@@ -33,6 +32,9 @@ SYSTEM_PROMPT = """
 4. Если пользователь просит найти информацию, например, "найди что-то про Адольфа Гитлера":
    - Ответь с текстом [SEARCH: {prompt}]
    - Затем используй полученную информацию для ответа на вопрос
+4.1 Если ты не знаешь информации которая пользователь запрашивает то напиши:
+    [SEARCH: {PROMPT}] 
+    вот тут информацию которую ты не знаешь
 5. Если пользователь просит нарисовать или сгенерировать изображение:
    - Начните ответ с [GENERATE_IMAGE]
    - Напишите детальный промпт на английском языке
@@ -146,10 +148,10 @@ def generate_image(prompt: str) -> str:
     try:
         client = Client()
         response = client.images.generate(
-            model="flux-pro",
+            model="flux-schnell-black-forest-labs",
             prompt=prompt,
             response_format="url",
-        
+            provider='HuggingSpace'
         )
         
         image_url = response.data[0].url
@@ -176,472 +178,131 @@ def generate_image(prompt: str) -> str:
 
     except Exception as e:
         return f"Ошибка при генерации изобраения: {str(e)}"
-
 def process_image(image_input) -> str:
-    """Обработка изображения и распознавание объектов через YOLOv8 и текста через EasyOCR"""
+    """Обработка изображения через провайдера Blackbox."""
     try:
-        # Загружаем модель YOLOv8n
-        model = YOLO('yolov8n.pt')
-        
-        # Инициализируем EasyOCR для русского и английского языков
-        reader = easyocr.Reader(['ru', 'en'])
-        
-        # Обработка входного изображения
-        if isinstance(image_input, str):
-            response = requests.get(image_input)
-            image = Image.open(io.BytesIO(response.content))
-        elif isinstance(image_input, Image.Image):
+        # Инициализация клиента GPT с провайдером Blackbox
+        client = Client()
+
+        # Определяем, как было передано изображение (URL или объект PIL.Image)
+        if isinstance(image_input, str):  # Если передан URL изображения
+            response = requests.get(image_input, stream=True)
+            if response.status_code == 200:
+                image = Image.open(response.raw)  # Преобразуем поток в объект PIL.Image
+            else:
+                return "❌ Ошибка загрузки изображения по URL."
+        elif isinstance(image_input, Image.Image):  # Если передано изображение PIL
             image = image_input
         else:
-            return "[IMAGE]\n❌ Неподдерживаемый формат изображения\n[/IMAGE]"
-        
-        # Конвертируем изображение в RGB если оно в RGBA
-        if image.mode == 'RGBA':
+            return "❌ Неподдерживаемый формат изображения."
+
+        # Конвертируем изображение в режим RGB, если оно в RGBA или другом формате
+        if image.mode != 'RGB':
             image = image.convert('RGB')
-        
-        # Сохраняем изображение во временный файл для обработки
-        with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp:
-            image.save(tmp.name, format='JPEG')
-            # Запускаем распознавание объектов
-            results = model(tmp.name)
-            
-            # Распознаем текст
-            text_results = reader.readtext(tmp.name)
-            
-        # Собираем найденные объекты
-        detected_objects = []
-        for r in results:
-            for box in r.boxes:
-                class_id = int(box.cls)
-                class_name = model.names[class_id]
-                detected_objects.append(class_name)
-        
-        # Собираем найденный текст
-        detected_text = []
-        for detection in text_results:
-            text = detection[1]
-            if text.strip():  # Проверяем, что текст не пу��той
-                detected_text.append(text)
-        
-        if not detected_objects and not detected_text:
-            return """
-<div class="image-analysis-animation">
-    <div class="analysis-text">К сожалению, я не смог распознать объекты на этом изобраении</div>
-</div>
-"""
-            
-        # Формируем сообщение для GPT
-        prompt = "Я на этом изображении вижу "
-        if detected_objects:
-            objects_str = ", ".join(detected_objects)
-            prompt += f"следующие объекты: {objects_str}. "
-            
-        if detected_text:
-            text_str = ", ".join(detected_text)
-            prompt += f"Также на изображении есть текст: {text_str}"
-            
-        messages = [
-            {
-                "role": "system",
-                "content": """Ты - система компьютерного зрения. 
-                Тебе нужно:
-                1. Перевести названия объектов на русский язык
-                2. Описать что ты видишь простыми словами
-                3. Всегда отвечать на русском языке
-                4. Если есть текст, упомянуть его в описании
-                5. Никогда не говори "Похоже,что у вас есть описание изображения..."
-                """
-            },
-            {
-                "role": "user",
-                "content": prompt
-            }
-        ]
-        
-        response = g4f.ChatCompletion.create(
+
+        # Сохраняем изображение во временный файл
+        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp:
+            image.save(tmp.name, format="JPEG")  # Сохраняем изображение как JPEG
+            image_file = open(tmp.name, "rb")  # Открываем файл для передачи в запрос
+
+        # Запрос на анализ изображения через Blackbox
+        response = client.chat.completions.create(
             model="gpt-4o",
-            messages=messages
+            messages=[{"role": "user", "content": "Опишите, что изображено на этом изображении."}],
+            image=image_file,
+            provider="Blackbox"
         )
-        
-        return response if isinstance(response, str) else prompt
+
+        # Закрываем временный файл
+        image_file.close()
+
+        # Возвращаем результат анализа
+        return response.choices[0].message.content
 
     except Exception as e:
         return f"❌ Ошибка при обработке изображения: {str(e)}"
     finally:
-        if 'tmp' in locals():
+        # Удаляем временный файл после использования
+        if "tmp" in locals():
             Path(tmp.name).unlink(missing_ok=True)
-
 def chat_response(message, history, model_name, direct_mode, thinking_depth=1.0, uploaded_file=None):
     messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+    partial_message = ""  # Инициализация переменной
     history = history or []
     history.append({"role": "user", "content": message})
     history.append({"role": "assistant", "content": ""})
-   
+    
     try:
-        # Проверяем, содержит ли сообщение [SEARCH:]
-        if "[SEARCH:" in message:
-            print("Поиск информации...")  # Отладочное сообщение
-            prompt = message.split("[SEARCH:")[1].strip(" ]")  # Извлекаем текст запроса
-            response_text = f"[SEARCH: {prompt}]\n"  # Форматируем ответ
-            history[-1]["content"] = response_text  # Обновляем историю с запросом поиска
-            
-            # Выполняем поиск информации
-            results = search_info(prompt)  # Ищем информацию
-            if not results:
-                history.append({"role": "assistant", "content": "Не удалось найти информацию."})
-                yield history, *[gr.update(visible=False) for _ in range(6)]
-                return
-            
-            info_text = ""
-            for link in results:
-                info_text += f"Ссылка: {link}\n"
-                text = get_page_text(link)
-                info_text += f"Текст: {text}\n\n"  # Добавляем текст страницы
-            print(f"Вот информация по запросу '{prompt}':\n\n{info_text}\nСделай краткий ответ на основе этой информации.")
-            # Формируем запрос для GPT
-            web_search = f"Вот информация по запросу '{prompt}':\n\n{info_text}\nСделай краткий ответ на основе этой информации."
-            print("Отправка запроса к GPT...")  # Отладочное сообщение
-            response = g4f.ChatCompletion.create(
-                model="gpt-4o",
-                messages=[
-                    {"role": "system", "content": "Сделай краткий ответ на основе следующей информации:"},
-                    {"role": "user", "content": web_search}
-                ],
-                stream=True,
-            )
-            
-            # Получаем ответ от GPT
-            if isinstance(response, str):
-                final_response = response
-            else:
-                final_response = "Не удалось получить ответ."
-            
-            history.append({"role": "assistant", "content": final_response})  # Добавляем ответ ИИ
-            yield history, *[gr.update(visible=False) for _ in range(6)]
-            return
+        # Обычный поток обработки сообщений
+        for msg in history[:-2]:
+            messages.append({"role": msg["role"], "content": msg["content"]})
+        messages.append({"role": "user", "content": str(message)})
+
+        partial_message = ""
+        response = None  # Инициализация переменной response
+        response = g4f.ChatCompletion.create(
+            model=AVAILABLE_MODELS.get(model_name, "O3"),
+            messages=messages,
+            stream=False,
+            provider="PollinationsAI"
+        )
         
-        if model_name == "GPT-4o THINK":
-            max_retries = 5
-            retry_count = 0
-            
-            # Формируем thinking_prompt
-            min_steps = 2
-            max_steps = 25
-            thinking_depth = float(thinking_depth)
-            num_steps = max(min_steps, int(thinking_depth))
+        if response and isinstance(response, str):
+            partial_message += response
+            history[-1]["content"] = f"""
+            <div class="text-fade-in">
+                {partial_message}
+            </div>
+            """
             
-            thinking_prompt = f"""Ты - система глубокого анализа. Твоя задача - максимально подробно проанализировать вопрос.
-
-Глубина анализа: {thinking_depth:.1f}/10
-Количество шагов размышления: {num_steps}
-
-ВАЖНО: Строго соблюдай формат ответа. Каждый тег должен быть на новой строке:
+            yield history, *[gr.update(visible=False) for _ in range(6)]
 
-[THINKING_STEP
-Текст первого шага...
-[/THINKING_STEP
+            # Если в ответе от модели есть [SEARCH:], выполняем поиск
+            if "[SEARCH:" in partial_message:
+                history[-1]["content"] = """
+                <div class="search-animation">
+                    <div class="search-text">🔍 Выполняется поиск...</div>
+                </div>
+                """
+                yield history, *[gr.update(visible=False) for _ in range(6)]
+                prompt = partial_message.split("[SEARCH:")[1].split("]")[0].strip()
 
-[THINKING_STEP
-Текст второго шага...
-[/THINKING_STEP
+                # Выполняем поиск
+                results = search_info(prompt)
+                if not results:
+                    history[-1]["content"] = "Не удалось найти информацию."
+                    yield history, *[gr.update(visible=False) for _ in range(6)]
+                    return
 
-[FINAL_ANSWER
-Итоговый ответ...
-[/FINAL_ANSWER
+                info_text = ""
+                for link in results:
+                    info_text += f"Ссылка: {link}\n"
+                    page_text = get_page_text(link)
+                    info_text += f"Текст: {page_text}...\n\n"
+                
+                search_response_prompt = f"""Вот информация по запросу "{prompt}":
+                
+{info_text}
 
-Вопрос: {message}
+На основе этой информации сформируй краткий и понятный ответ на русском языке.
 """
-            
-            while retry_count < max_retries:
-                try:
-                    # Показываем статус попытки
-                    thinking_html = f"""
-                    <div class="thinking-animation">
-                        <div class="thinking-step">🤔 Думаю...</div>
-                    </div>
-                    """
-                    history[-1]["content"] = thinking_html
-                    yield history, *[gr.update(visible=False) for _ in range(6)]
-                    print('Об��аботка запроса')
-                    # Создаем запрос с таймаутом только для первого чанка
-                    response = g4f.ChatCompletion.create(
-                        model="gpt-4o",
-                        messages=[{"role": "system", "content": thinking_prompt}],
-                        stream=True
-                    )
-                    
-                    # Флаг для отслеживания получения первого чанка
-                    received_first_chunk = False
-                    partial_message = ""
-                    current_block = ""
-                    in_thinking_step = False
-                    in_final_answer = False
-                    
-                    for chunk in response:
-                        if chunk and isinstance(chunk, str):
-                            received_first_chunk = True
-                            current_block += chunk
-                            
-                            # Исправляем неправильно закрытые теги
-                            # ... существующий код ...
-                            current_block = (current_block
-                                .replace("[/THINKING_STEP\n", "[/THINKING_STEP]\n")  # Исправляем закрывающий тег THINKING_STEP
-                                .replace("[/FINAL_ANSWER\n", "[/FINAL_ANSWER]\n")    # Исправляем закрывающий тег FINAL_ANSWER
-                                .replace("\n[/THINKING_STEP", "\n[/THINKING_STEP]")   # Исправляем порядок закрывающего тега THINKING_STEP
-                                .replace("\n[/FINAL_ANSWER", "\n[/FINAL_ANSWER]")     # Исправляем порядок закрывающего тега FINAL_ANSWER
-                                .replace("]]]]]]", "")  # Убираем лишние закрывающие скобки
-                                .replace("]]", "")      # Убираем лишние закрывающие скобки
-                                .replace("]", "")  # Исправляем закрывающий тег THINKING_STEP с учетом закрывающей скобки
-                            )
-                            # ... существующий код ...
-                            
-                            if "[THINKING_STEP]" in current_block:
-                                in_thinking_step = True
-                                current_block = current_block.replace("[THINKING_STEP]", "")
-                            if "[THINKING_STEP" in current_block:
-                                in_thinking_step = True
-                                current_block = current_block.replace("[THINKING_STEP", "")
-                                
-                            if "[FINAL_ANSWER]" in current_block:
-                                in_final_answer = True
-                                current_block = current_block.replace("[FINAL_ANSWER]", "")
-                            if "[FINAL_ANSWER" in current_block:
-                                in_final_answer = True
-                                
-                                current_block = current_block.replace("[FINAL_ANSWER", "")
-                                
-                                # Проверяем завершение блоков
-                            if "[/THINKING_STEP]" in current_block and in_thinking_step:
-                                block_content = current_block[:current_block.find("[/THINKING_STEP]")]
-                                formatted_block = f'<div class="thinking-step-block">{block_content}</div>'
-                                partial_message += formatted_block
-                                current_block = current_block[current_block.find("[/THINKING_STEP]") + len("[/THINKING_STEP]"):]
-                                in_thinking_step = False
-                            if "[/THINKING_STEP" in current_block and in_thinking_step:
-                                block_content = current_block[:current_block.find("[/THINKING_STEP")]
-                                formatted_block = f'<div class="thinking-step-block">{block_content}</div>'
-                                partial_message += formatted_block
-                                current_block = current_block[current_block.find("[/THINKING_STEP") + len("[/THINKING_STEP"):]
-                                in_thinking_step = False
-                                
-                            elif "[/FINAL_ANSWER]" in current_block and in_final_answer:
-                                block_content = current_block[:current_block.find("[/FINAL_ANSWER]")]
-                                formatted_block = f'<div class="final-answer-block">{block_content}</div>'
-                                partial_message += formatted_block
-                                current_block = current_block[current_block.find("[/FINAL_ANSWER") + len("[/FINAL_ANSWER]"):]
-                                in_final_answer = False
-                            elif "[/FINAL_ANSWER" in current_block and in_final_answer:
-                                block_content = current_block[:current_block.find("[/FINAL_ANSWER")]
-                                formatted_block = f'<div class="final-answer-block">{block_content}</div>'
-                                partial_message += formatted_block
-                                current_block = current_block[current_block.find("[/FINAL_ANSWER") + len("[/FINAL_ANSWER"):]
-                                in_final_answer = False
-                            
-                            # Убираем лишние пробелы и переносы строк
-                            display_message = partial_message + current_block.strip()
-                            history[-1]["content"] = display_message
-                            yield history, *[gr.update(visible=False) for _ in range(6)]
-                            
-                            # # Если получили первый чанк, создаем новый стрим без таймаута
-                            # if received_first_chunk:
-                            #     response = g4f.ChatCompletion.create(
-                            #         model="gpt-4o",
-                            #         messages=[{"role": "system", "content": thinking_prompt}],
-                            #         stream=True,
-                            #         provider=g4f.Provider.Airforce
-                            #     )
-                            #     break
-                    
-                    # Продолжаем обработку без таймаута
-                    if received_first_chunk:
-                        for chunk in response:
-                            if chunk and isinstance(chunk, str):
-                                current_block += chunk
-                                
-                                # Исправляем неправильно закрытые теги
-                                                                # ... существующий код ...
-                                current_block = (current_block
-                                    .replace("[/THINKING_STEP\n", "[/THINKING_STEP]\n")  # Исправляем закрывающий тег THINKING_STEP
-                                    .replace("[/THINKING_STEP", "[/THINKING_STEP]\n")  # Исправляем закрывающий тег THINKING_STEP
-                                    # .replace("[/THINKING_STEP]", "[/THINKING_STEP]\n")  # Исправляем закрывающий тег THINKING_STEP с учетом закрывающей скобки
-                                    
-                                    .replace("[/FINAL_ANSWER\n", "[/FINAL_ANSWER]\n")    # Исправляем закрывающий тег FINAL_ANSWER
-                                    .replace("[/FINAL_ANSWER]", "[/FINAL_ANSWER]\n")      # Исправляем закрывающий тег FINAL_ANSWER с учетом закрывающей скобки
-                                    .replace("\n[/THINKING_STEP", "\n[/THINKING_STEP]")   # Исправляем порядок закрывающего тега THINKING_STEP
-                                    .replace("\n[/FINAL_ANSWER", "\n[/FINAL_ANSWER]")     # Исправляем порядок закрывающего тега FINAL_ANSWER
-                                    .replace("]]]]]]", "")  # Убираем лишние закрывающие скобки
-                                    .replace("]]", "")      # Убираем лишние закрывающие скобки
-                                    .replace("]", "")      # Убираем лишние закрывающие скобки
-                                    
-                                )
-     
-                                
-                                # Проверяем начало блоков
-                                if "[THINKING_STEP]" in current_block:
-                                    in_thinking_step = True
-                                    current_block = current_block.replace("[THINKING_STEP]", "")
-                                if "[THINKING_STEP" in current_block:
-                                    in_thinking_step = True
-                                    current_block = current_block.replace("[THINKING_STEP", "")
-                                
-                                if "[FINAL_ANSWER]" in current_block:
-                                    in_final_answer = True
-                                    current_block = current_block.replace("[FINAL_ANSWER]", "")
-                                if "[FINAL_ANSWER" in current_block:
-                                    in_final_answer = True
-                                    current_block = current_block.replace("[FINAL_ANSWER", "")
-                                
-                                # Проверяем завершение блоков
-                                if "[/THINKING_STEP]" in current_block and in_thinking_step:
-                                    block_content = current_block[:current_block.find("[/THINKING_STEP]")]
-                                    formatted_block = f'<div class="thinking-step-block">{block_content}</div>'
-                                    partial_message += formatted_block
-                                    current_block = current_block[current_block.find("[/THINKING_STEP]") + len("[/THINKING_STEP]"):]
-                                    in_thinking_step = False
-                                if "[/THINKING_STEP" in current_block and in_thinking_step:
-                                    block_content = current_block[:current_block.find("[/THINKING_STEP")]
-                                    formatted_block = f'<div class="thinking-step-block">{block_content}</div>'
-                                    partial_message += formatted_block
-                                    current_block = current_block[current_block.find("[/THINKING_STEP") + len("[/THINKING_STEP"):]
-                                    in_thinking_step = False
-                                
-                                elif "[/FINAL_ANSWER]" in current_block and in_final_answer:
-                                    block_content = current_block[:current_block.find("[/FINAL_ANSWER]")]
-                                    formatted_block = f'<div class="final-answer-block">{block_content}</div>'
-                                    partial_message += formatted_block
-                                    current_block = current_block[current_block.find("[/FINAL_ANSWER") + len("[/FINAL_ANSWER]"):]
-                                    in_final_answer = False
-                                elif "[/FINAL_ANSWER" in current_block and in_final_answer:
-                                    block_content = current_block[:current_block.find("[/FINAL_ANSWER")]
-                                    formatted_block = f'<div class="final-answer-block">{block_content}</div>'
-                                    partial_message += formatted_block
-                                    current_block = current_block[current_block.find("[/FINAL_ANSWER") + len("[/FINAL_ANSWER"):]
-                                    in_final_answer = False
-                                
-                                # Убираем лишние пробелы и переносы строк
-                                display_message = partial_message + current_block.strip()
-                                history[-1]["content"] = display_message
-                                yield history, *[gr.update(visible=False) for _ in range(6)]
-                        break
-                        
-                    retry_count += 1
-                    if retry_count == max_retries:
-                        error_message = f"""
-                        <div class="error-animation">
-                            <div class="error-text">❌ Не удалось получить ответ после {max_retries} попыток. 
-                            Попробуйте использовать обычный режим или повторите запрос позже.</div>
-                        </div>
-                        """
-                        history[-1]["content"] = error_message
-                        yield history, *[gr.update(visible=False) for _ in range(6)]
-                        return
-                        
-                except Exception as e:
-                    retry_count += 1
-                    if retry_count == max_retries:
-                        error_message = f"""
-                        <div class="error-animation">
-                            <div class="error-text">❌ Ошибка при анализе: {str(e)}</div>
-                        </div>
-                        """
-                        history[-1]["content"] = error_message
-                        yield history, *[gr.update(visible=False) for _ in range(6)]
-                        return
+                search_response = g4f.ChatCompletion.create(
+                    model="gpt-4",
+                    messages=[{"role": "user", "content": search_response_prompt}],
+                    stream=False,
+                    provider="Mhystical"
+                )
 
-        else:
-            # Обычный режим работы
-            if direct_mode:
-                # Прямая отправка в нейронку для генерации изображения
-                image_url = generate_image(message)
-                if not image_url.startswith("Ошибка"):
-                    history[-1]["content"] = f"![Generated Image]({image_url})"
-                else:
-                    history[-1]["content"] = f"❌ {image_url}"
+                final_response = search_response if isinstance(search_response, str) else "Не удалось получить ответ."
+                final_response = final_response.replace(f"[SEARCH: {prompt}]", "").strip()
+                history.append({"role": "assistant", "content": final_response})
                 yield history, *[gr.update(visible=False) for _ in range(6)]
                 return
 
-            # Начальные значения
-            yield (
-                history,
-                gr.update(visible=False),
-                gr.update(visible=False),
-                gr.update(visible=False),
-                "",
-                gr.update(visible=False),
-                gr.update(visible=False)
-            )
-            
-            if uploaded_file:
-                file_content = process_file(uploaded_file)
-                if file_content:
-                    message = f"Файл содержит:\n```\n{file_content}\n```\n\n{message}"
-
-            # ормируем историю сообщений
-            for msg in history[:-2]:
-                messages.append({"role": msg["role"], "content": msg["content"]})
-            messages.append({"role": "user", "content": str(message)})
-
-            partial_message = ""
-            code_block = None
-            
-            response = g4f.ChatCompletion.create(
-                model=AVAILABLE_MODELS.get(model_name, "gpt-4o"),
-                messages=messages,
-                stream=True,
-                provider=g4f.Provider.Airforce
-            )
-            
-            for chunk in response:
-                if chunk and isinstance(chunk, str):
-                    partial_message += chunk
-                    
-                    # Проверяем на запрос генерации изображения
-                    if "[GENERATE_IMAGE]" in partial_message and "[/GENERATE_IMAGE]" in partial_message:
-                        start_idx = partial_message.find("[GENERATE_IMAGE]") + len("[GENERATE_IMAGE]")
-                        end_idx = partial_message.find("[/GENERATE_IMAGE]")
-                        image_prompt = partial_message[start_idx:end_idx].strip()
-                        
-                        # Показываем статус генерации
-                        history[-1]["content"] = """
-                        <div class="generating-animation">
-                            <div class="generating-text">Генерация изображения...</div>
-                        </div>
-                        """
-                        yield history, *[gr.update(visible=False) for _ in range(6)]
-                        
-                        # Генерируем изображение
-                        image_url = generate_image(image_prompt)
-                        
-                        if not image_url.startswith("Ошибка"):
-                            # Анализируем изображение
-                            # image_analysis = process_image(image_url)
-                            explanation_text = partial_message[end_idx + len("[/GENERATE_IMAGE]"):].strip()
-                            partial_message = f"![Generated Image]({image_url})\n\n{explanation_text}"
-                        else:
-                            partial_message = f"❌ {image_url}"
-                    
-                    history[-1]["content"] = partial_message + "▓"
-                    yield history, *[gr.update(visible=False) for _ in range(6)]
-                    
-                    # Проверяем наличие кода
-                    if "```" in partial_message:
-                        code_start = partial_message.rfind("```") + 3
-                        code_end = partial_message.find("```", code_start)
-                        if code_end != -1:
-                            code_block = partial_message[code_start:code_end].strip()
-            
-            # В конце убирае курсор и сбрасываем файл
-            history[-1]["content"] = partial_message
-            yield (
-                history, 
-                *[gr.update(visible=True if code_block else False) for _ in range(5)],
-                gr.update(value=None)  # Сбрасываем файл после ответа
-            )
+        history[-1]["content"] = partial_message.strip()
+        yield history, *[gr.update(visible=True) for _ in range(6)]
 
     except Exception as e:
-        print(f"Error: {e}")
-        if not history:
-            history = [{"role": "user", "content": message}, {"role": "assistant", "content": ""}]
         history[-1]["content"] = f"❌ Произошла ошибка: {str(e)}"
         yield (
             history,
@@ -650,9 +311,86 @@ def chat_response(message, history, model_name, direct_mode, thinking_depth=1.0,
             gr.update(visible=True),
             "",
             gr.update(visible=False),
-            gr.update(value=None)  # Сбрасываем файл в случае ошибки
+            gr.update(value=None)
         )
 
+    if direct_mode:
+        image_url = generate_image(message)
+        if not image_url.startswith("Ошибка"):
+            history[-1]["content"] = f"![Generated Image]({image_url})"
+        else:
+            history[-1]["content"] = f"❌ {image_url}"
+        yield history, *[gr.update(visible=False) for _ in range(6)]
+        return
+
+    yield (
+        history,
+        gr.update(visible=False),
+        gr.update(visible=False),
+        gr.update(visible=False),
+        "",
+        gr.update(visible=False),
+        gr.update(visible=False)
+    )
+    
+    if uploaded_file:
+        file_content = process_file(uploaded_file)
+        if file_content:
+            message = f"Файл содержит:\n```\n{file_content}\n```\n\n{message}"
+
+    for msg in history[:-2]:
+        messages.append({"role": msg["role"], "content": msg["content"]})
+    messages.append({"role": "user", "content": str(message)})
+
+    partial_message = ""
+    code_block = None
+    response = g4f.ChatCompletion.create(
+        model=AVAILABLE_MODELS.get(model_name, "O3"),
+        messages=messages,
+        stream=False,
+        provider="PollinationsAI"
+    )
+    
+    if response and isinstance(response, str):
+        partial_message += response
+        if "[GENERATE_IMAGE]" in partial_message:
+            history[-1]["content"] = """
+            <div class="generating-animation">
+                <div class="generating-text">Генерация изображения...</div>
+            </div>
+            """
+        
+        if "[GENERATE_IMAGE]" in partial_message and "[/GENERATE_IMAGE]" in partial_message:
+            start_idx = partial_message.find("[GENERATE_IMAGE]") + len("[GENERATE_IMAGE]")
+            end_idx = partial_message.find("[/GENERATE_IMAGE]")
+            image_prompt = partial_message[start_idx:end_idx].strip()
+            yield history, *[gr.update(visible=False) for _ in range(6)]
+            
+            image_url = generate_image(image_prompt)
+            
+            if not image_url.startswith("Ошибка"):
+                explanation_text = partial_message[end_idx + len("[/GENERATE_IMAGE]"):].strip()
+                partial_message = f"![Generated Image]({image_url})\n\n{explanation_text}"
+            else:
+                partial_message = f"❌ {image_url}"
+        
+        history[-1]["content"] = partial_message + "|"
+        yield history, *[gr.update(visible=False) for _ in range(6)]
+        
+        if "```" in partial_message:
+            code_start = partial_message.rfind("```") + 3
+            code_end = partial_message.find("```", code_start)
+            if code_end != -1:
+                code_block = partial_message[code_start:code_end].strip()
+    
+    history[-1]["content"] = partial_message
+    yield (
+        history, 
+        *[gr.update(visible=True if code_block else False) for _ in range(5)],
+        gr.update(value=None)
+    )
+
+
 def analyze_code(code):
     """Анализ кода и получение объяснения"""
     if not code:
@@ -705,11 +443,75 @@ def create_interface():
         border-radius: 10px;
         box-shadow: 0 2px 6px rgba(0,0,0,0.15);
     }
+    .text-fade-in {
+        opacity: 0;  /* Исходная прозрачность */
+        transform: translateY(10px);  /* Исходное смещение */
+        animation: fadeInText 1s ease-in-out forwards;  /* Анимация при показе */
+    }
+
+    @keyframes fadeInText {
+        0% {
+            opacity: 0;
+            transform: translateY(10px);  /* Немного ниже */
+        }
+        100% {
+            opacity: 1;
+            transform: translateY(0);  /* Возвращается на место */
+        }
+    }
+
     .message.user {
         background-color: #3d3d3d !important;
         color: white !important;
         border-radius: 15px;
     }
+    .search-animation {
+        position: relative;
+        width: 100%;
+        min-height: 80px;
+        background: linear-gradient(45deg, #2d2d2d, #3d3d3d);
+        border-radius: 15px;
+        overflow: hidden;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+    }
+
+    .search-text {
+        color: white;
+        font-size: 18px;
+        z-index: 2;
+        animation: search-pulse 1.5s infinite;
+    }
+
+    .search-animation::before {
+        content: '';
+        position: absolute;
+        width: 200%;
+        height: 200%;
+        top: -50%;
+        left: -50%;
+        background: 
+            radial-gradient(2px 2px at 20% 30%, rgba(255,255,255,0.3), rgba(0,0,0,0)),
+            radial-gradient(2px 2px at 40% 70%, rgba(255,255,255,0.3), rgba(0,0,0,0));
+        background-repeat: repeat;
+        animation: search-rotate 6s linear infinite;
+    }
+
+    @keyframes search-pulse {
+        0% { opacity: 0.6; }
+        50% { opacity: 1; }
+        100% { opacity: 0.6; }
+    }
+
+    @keyframes search-rotate {
+        from {
+            transform: rotate(0deg);
+        }
+        to {
+            transform: rotate(360deg);
+        }
+    }
     .message.bot {
         background-color: #2d2d2d !important;
         color: white !important;
@@ -1035,21 +837,7 @@ def create_interface():
                     render_markdown=True
                 )
                 
-                # Добавляем компоненты для вывода
-                output_text = gr.Textbox(
-                    label="Вывод",
-                    interactive=False,
-                    visible=False
-                )
-                error_text = gr.Textbox(
-                    label="⚠️ Ошибки",
-                    interactive=False,
-                    visible=False
-                )
-                ask_help_btn = gr.Button(
-                    "❓ Спросить почему возникла ошибка",
-                    visible=False
-                )
+
                 
                 with gr.Row(elem_classes="input-row"):
                     msg = gr.Textbox(
@@ -1071,7 +859,7 @@ def create_interface():
             with gr.Column(scale=1, visible=True) as sidebar:
                 model = gr.Dropdown(
                     choices=list(AVAILABLE_MODELS.keys()),
-                    value="GPT-4o",
+                    value="O3 (NEW)",
                     label="Модель"
                 )
                 
@@ -1107,64 +895,25 @@ def create_interface():
             elem_classes="run-btn"
         )
         
-        def run_code(code):
-            if not code:
-                return {
-                    output_text: gr.update(value=" Нет кода для выполнения", visible=True),
-                    error_text: gr.update(visible=False),
-                    ask_help_btn: gr.update(visible=False)
-                }
-            
-            result = test_code(code)
-            
-            return {
-                output_text: gr.update(value=result["output"] if result["success"] else "", visible=True),
-                error_text: gr.update(value=result["error"], visible=bool(result["error"])),
-                # ask_help_btn: gr.update(visible=bool(result["error"]))
-            }
-
-        def handle_error_question(error_message, code_block):
-            """Обработчик кнопки помощи с ошибкой"""
-            error_prompt = f"""Объясните ошибку и как её исправить:
-
-Код:
-```
-{code_block}
-```
 
-Ошибка:
-{error_message}"""
-    
-            try:
-                response = g4f.ChatCompletion.create(
-                    model="gpt-3.5-turbo",
-                    messages=[{"role": "user", "content": error_prompt}],
-                    stream=False
-                )
-                return [{"role": "assistant", "content": response if isinstance(response, str) else "Не удалось получиь ответ"}]
-            except Exception as e:
-                return [{"role": "assistant", "content": f"Ошибка при получнии объяснения: {str(e)}"}]
+          
     
         # Обработчики событий
         msg.submit(
             fn=chat_response,
             inputs=[msg, chatbot, model, direct_mode, thinking_depth, file_output],
-            outputs=[chatbot, output_text, error_text, ask_help_btn, current_code, analyze_btn, run_btn],
+            outputs=[chatbot, current_code],
             api_name=None
         )
 
         submit.click(
             fn=chat_response,
             inputs=[msg, chatbot, model, direct_mode, thinking_depth, file_output],
-            outputs=[chatbot, output_text, error_text, ask_help_btn, current_code, analyze_btn, run_btn],
+            outputs=[chatbot, current_code],
             api_name=None
         )
 
-        ask_help_btn.click(
-            fn=handle_error_question,
-            inputs=[error_text, current_code],
-            outputs=chatbot
-        )
+
 
         analyze_btn.click(
             fn=analyze_code,
@@ -1172,15 +921,11 @@ def create_interface():
             outputs=[chatbot]
         )
         
-        run_btn.click(
-            fn=run_code,
-            inputs=[current_code],
-            outputs=[output_text, error_text, ask_help_btn]
-        )
+
         
         clear.click(
             fn=lambda: (None, "", "", False, ""),
-            outputs=[chatbot, output_text, error_text, ask_help_btn, current_code]
+            outputs=[chatbot, current_code]
         )
 
         # Добавляем обработчик изменения модели