smart-bot-factory 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

smart_bot_factory/handlers/handlers.py

@@ -5,7 +5,7 @@ import time
 from aiogram import Router, F
 from aiogram.filters import Command, StateFilter
 from aiogram.fsm.context import FSMContext
-from aiogram.types import Message
+from aiogram.types import Message, CallbackQuery
 
 from ..core.bot_utils import send_message, parse_ai_response, process_events, send_welcome_file
 from ..core.states import UserStates, AdminStates
@@ -172,7 +172,153 @@ async def timeup_handler(message: Message, state: FSMContext):
     except Exception as e:
         logger.error(f"❌ Критическая ошибка в timeup_handler: {e}")
         await message.answer(f"❌ Ошибка тестирования: {str(e)}")
-
+        
+@router.message(F.voice | F.audio)
+async def voice_handler(message: Message, state: FSMContext):
+    """Обработчик голосовых и аудио сообщений"""
+    openai_client = get_global_var('openai_client')
+    bot = get_global_var('bot')
+    admin_manager = get_global_var('admin_manager')
+    
+    import os
+    from pathlib import Path
+    from datetime import datetime
+    
+    processing_msg = None
+    
+    try:
+        # Проверяем что это не админ в режиме администратора
+        if admin_manager.is_admin(message.from_user.id):
+            if admin_manager.is_in_admin_mode(message.from_user.id):
+                return  # Админы работают с текстом
+        
+        logger.info(f"🎤 Получено голосовое сообщение от {message.from_user.id}")
+        
+        # Получаем файл
+        if message.voice:
+            file_id = message.voice.file_id
+            duration = message.voice.duration
+        else:
+            file_id = message.audio.file_id
+            duration = message.audio.duration
+        
+        # Показываем что обрабатываем
+        processing_msg = await message.answer("🎤 Распознаю голос...")
+        
+        try:
+            # Скачиваем файл
+            file = await bot.get_file(file_id)
+            
+            # Путь для сохранения
+            temp_dir = Path("temp_audio")
+            temp_dir.mkdir(exist_ok=True)
+            
+            file_path = temp_dir / f"{message.from_user.id}_{int(datetime.now().timestamp())}.ogg"
+            
+            # Скачиваем
+            await bot.download_file(file.file_path, file_path)
+            logger.info(f"📥 Файл скачан: {file_path} ({duration} сек)")
+            
+            # Распознаем через Whisper
+            recognized_text = await openai_client.transcribe_audio(str(file_path))
+            
+            # Удаляем временный файл
+            try:
+                os.remove(file_path)
+                logger.info(f"🗑️ Временный файл удален: {file_path}")
+            except Exception as e:
+                logger.warning(f"⚠️ Не удалось удалить временный файл: {e}")
+            
+            if not recognized_text:
+                await processing_msg.edit_text("❌ Не удалось распознать голос. Попробуйте еще раз.")
+                return
+            
+            logger.info(f"✅ Текст распознан успешно: '{recognized_text[:100]}...'")
+            
+            # Получаем данные сессии
+            current_state = await state.get_state()
+            data = await state.get_data()
+            
+            logger.info(f"🔍 Текущее состояние: {current_state}")
+            logger.info(f"🔍 Данные в state: {data}")
+            
+            session_id = data.get('session_id')
+            system_prompt = data.get('system_prompt')
+            
+            logger.info(f"📝 session_id из state: {session_id}")
+            
+            # Если session_id нет в state, пытаемся получить из БД
+            if not session_id:
+                logger.warning(f"⚠️ session_id не найден в state, ищем активную сессию в БД...")
+                supabase_client = get_global_var('supabase_client')
+                
+                session_info = await supabase_client.get_active_session(message.from_user.id)
+                if session_info:
+                    session_id = session_info['id']
+                    system_prompt = session_info['system_prompt']
+                    
+                    # Сохраняем в state для следующих сообщений
+                    await state.update_data(session_id=session_id, system_prompt=system_prompt)
+                    await state.set_state(UserStates.waiting_for_message)
+                    
+                    logger.info(f"✅ Сессия восстановлена из БД: {session_id}")
+                else:
+                    logger.error(f"❌ Активная сессия не найдена в БД")
+            
+            if session_id:
+                # Сохраняем распознанный текст в state
+                await state.update_data(voice_recognized_text=recognized_text)
+                await state.set_state(UserStates.voice_confirmation)
+                
+                # Показываем распознанный текст с кнопками выбора
+                from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+                
+                keyboard = InlineKeyboardMarkup(inline_keyboard=[
+                    [InlineKeyboardButton(text="✅ Отправить", callback_data="voice_send")],
+                    [InlineKeyboardButton(text="✏️ Изменить текст", callback_data="voice_edit")],
+                    [InlineKeyboardButton(text="🎤 Надиктовать заново", callback_data="voice_retry")]
+                ])
+                
+                # Удаляем сообщение "Обрабатываю"
+                try:
+                    await processing_msg.delete()
+                except:
+                    pass
+                
+                # Показываем результат с кнопками
+                await message.answer(
+                    f"✅ Распознано:\n\n<i>{recognized_text}</i>\n\n"
+                    f"Выберите действие:",
+                    reply_markup=keyboard,
+                    parse_mode='HTML'
+                )
+                
+                logger.info(f"✅ Показаны кнопки подтверждения голосового сообщения")
+            else:
+                logger.warning(f"❌ Нет session_id в состоянии")
+                await processing_msg.edit_text(
+                    f"✅ Распознано:\n\n{recognized_text}\n\n"
+                    f"Сессия не найдена. Напишите /start"
+                )
+                
+        except Exception as e:
+            logger.error(f"❌ Ошибка в процессе обработки голоса: {e}")
+            logger.exception("Полный стек ошибки:")
+            if processing_msg:
+                await processing_msg.edit_text("❌ Ошибка обработки. Попробуйте написать текстом.")
+            else:
+                await message.answer("❌ Ошибка обработки. Попробуйте написать текстом.")
+        
+    except Exception as e:
+        logger.error(f"❌ КРИТИЧЕСКАЯ ошибка обработки голоса: {e}")
+        logger.exception("Полный стек критической ошибки:")
+        try:
+            if processing_msg:
+                await processing_msg.edit_text("❌ Ошибка распознавания. Попробуйте написать текстом.")
+            else:
+                await message.answer("❌ Ошибка распознавания. Попробуйте написать текстом.")
+        except:
+            pass
 
 async def user_start_handler(message: Message, state: FSMContext):
     """Обработчик /start для обычных пользователей"""
@@ -227,7 +373,8 @@ async def user_start_handler(message: Message, state: FSMContext):
             'medium': utm_data.get('utm_medium'),
             'campaign': utm_data.get('utm_campaign'),
             'content': utm_data.get('utm_content'),
-            'term': utm_data.get('utm_term')
+            'term': utm_data.get('utm_term'),
+            'segment': utm_data.get('segment')
         }
         
         # 4. СОЗДАЕМ НОВУЮ СЕССИЮ (автоматически закроет активные)
@@ -465,6 +612,112 @@ async def user_message_handler(message: Message, state: FSMContext):
     except Exception as e:
         logger.error(f"❌ Ошибка при обработке сообщения пользователя: {e}")
         await send_message(message, "Произошла ошибка. Попробуйте еще раз или напишите /start для перезапуска.")
+        
+@router.callback_query(F.data == "voice_send")
+async def voice_send_handler(callback: CallbackQuery, state: FSMContext):
+    """Обработчик кнопки 'Отправить' для голосового сообщения"""
+    try:
+        data = await state.get_data()
+        recognized_text = data.get('voice_recognized_text')
+        session_id = data.get('session_id')
+        system_prompt = data.get('system_prompt')
+        
+        if not recognized_text or not session_id:
+            await callback.answer("❌ Ошибка: текст не найден", show_alert=True)
+            return
+        
+        # Удаляем сообщение с кнопками
+        await callback.message.delete()
+        
+        # Обрабатываем текст сразу без промежуточного сообщения
+        await process_voice_message(callback.message, state, session_id, system_prompt, recognized_text)
+        
+        # Возвращаем в обычное состояние
+        await state.set_state(UserStates.waiting_for_message)
+        await state.update_data(voice_recognized_text=None)
+        
+        await callback.answer()
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка отправки голосового: {e}")
+        await callback.answer("❌ Ошибка обработки", show_alert=True)
+
+@router.callback_query(F.data == "voice_edit")
+async def voice_edit_handler(callback: CallbackQuery, state: FSMContext):
+    """Обработчик кнопки 'Изменить текст' для голосового сообщения"""
+    try:
+        data = await state.get_data()
+        recognized_text = data.get('voice_recognized_text')
+        
+        if not recognized_text:
+            await callback.answer("❌ Ошибка: текст не найден", show_alert=True)
+            return
+        
+        # Переводим в режим редактирования
+        await state.set_state(UserStates.voice_editing)
+        
+        # Показываем текст для редактирования (обычный формат)
+        await callback.message.edit_text(
+            f"✏️ Отредактируйте распознанный текст:\n\n"
+            f"{recognized_text}\n\n"
+            f"Напишите исправленный текст:"
+        )
+        
+        await callback.answer()
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка редактирования: {e}")
+        await callback.answer("❌ Ошибка", show_alert=True)
+
+@router.callback_query(F.data == "voice_retry")
+async def voice_retry_handler(callback: CallbackQuery, state: FSMContext):
+    """Обработчик кнопки 'Надиктовать заново' для голосового сообщения"""
+    try:
+        # Удаляем сообщение с кнопками
+        await callback.message.delete()
+        
+        # Возвращаем в обычное состояние
+        await state.set_state(UserStates.waiting_for_message)
+        await state.update_data(voice_recognized_text=None)
+        
+        # Просим отправить заново
+        await callback.message.answer("🎤 Отправьте голосовое сообщение заново")
+        
+        await callback.answer()
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка повтора: {e}")
+        await callback.answer("❌ Ошибка", show_alert=True)
+
+@router.message(StateFilter(UserStates.voice_editing))
+async def voice_edit_text_handler(message: Message, state: FSMContext):
+    """Обработчик получения отредактированного текста"""
+    try:
+        edited_text = message.text.strip()
+        
+        if not edited_text:
+            await message.answer("⚠️ Текст не может быть пустым. Напишите текст:")
+            return
+        
+        # Получаем данные сессии
+        data = await state.get_data()
+        session_id = data.get('session_id')
+        system_prompt = data.get('system_prompt')
+        
+        if not session_id:
+            await message.answer("❌ Сессия не найдена. Напишите /start")
+            return
+        
+        # Обрабатываем отредактированный текст сразу
+        await process_voice_message(message, state, session_id, system_prompt, edited_text)
+        
+        # Возвращаем в обычное состояние
+        await state.set_state(UserStates.waiting_for_message)
+        await state.update_data(voice_recognized_text=None)
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка обработки отредактированного текста: {e}")
+        await message.answer("❌ Ошибка обработки. Попробуйте еще раз или напишите /start")
 
 @router.message()
 async def catch_all_handler(message: Message, state: FSMContext):
@@ -778,4 +1031,135 @@ async def process_user_message(message: Message, state: FSMContext, session_id:
         try:
             await message.answer("Произошла критическая ошибка. Попробуйте написать /start для перезапуска.")
         except:
-            logger.error(f"❌ Не удалось отправить сообщение об критической ошибке")
+            logger.error(f"❌ Не удалось отправить сообщение об критической ошибке")
+            
+async def process_voice_message(message: Message, state: FSMContext, session_id: str, system_prompt: str, recognized_text: str):
+    """Обработка распознанного голосового сообщения"""
+    supabase_client = get_global_var('supabase_client')
+    openai_client = get_global_var('openai_client')
+    config = get_global_var('config')
+    bot = get_global_var('bot')
+    prompt_loader = get_global_var('prompt_loader')
+    
+    from datetime import datetime
+    import pytz
+    
+    try:
+        # Сохраняем распознанное сообщение как текст пользователя
+        await supabase_client.add_message(
+            session_id=session_id,
+            role='user',
+            content=recognized_text,
+            message_type='text',  # БД разрешает только 'text'
+            metadata={'original_type': 'voice', 'duration': message.voice.duration if message.voice else 0}
+        )
+        logger.info(f"✅ Распознанное сообщение сохранено в БД")
+        
+        # Получаем историю сообщений
+        chat_history = await supabase_client.get_chat_history(session_id, limit=config.MAX_CONTEXT_MESSAGES)
+        logger.info(f"📚 Загружена история: {len(chat_history)} сообщений")
+        
+        # Добавляем текущее время
+        moscow_tz = pytz.timezone('Europe/Moscow')
+        current_time = datetime.now(moscow_tz)
+        time_info = current_time.strftime('%H:%M, %d.%m.%Y, %A')
+        
+        system_prompt_with_time = f"""
+{system_prompt}
+
+ТЕКУЩЕЕ ВРЕМЯ: {time_info} (московское время)
+"""
+        
+        # Формируем контекст для OpenAI
+        messages = [{"role": "system", "content": system_prompt_with_time}]
+        
+        for msg in chat_history[-config.MAX_CONTEXT_MESSAGES:]:
+            messages.append({
+                "role": msg['role'],
+                "content": msg['content']
+            })
+        
+        # Добавляем финальные инструкции
+        final_instructions = await prompt_loader.load_final_instructions()
+        if final_instructions:
+            messages.append({"role": "system", "content": final_instructions})
+            logger.info(f"🎯 Добавлены финальные инструкции")
+        
+        logger.info(f"📝 Контекст сформирован: {len(messages)} сообщений")
+        
+        await bot.send_chat_action(message.chat.id, "typing")
+        
+        import time
+        start_time = time.time()
+        ai_response = await openai_client.get_completion(messages)
+        processing_time = int((time.time() - start_time) * 1000)
+
+        logger.info(f"🤖 OpenAI ответил за {processing_time}мс")
+        
+        tokens_used = 0
+        ai_metadata = {}
+        response_text = ""
+
+        if not ai_response or not ai_response.strip():
+            logger.warning(f"❌ OpenAI вернул пустой ответ!")
+            fallback_message = "Извините, произошла техническая ошибка. Попробуйте еще раз."
+            ai_response = fallback_message
+            response_text = fallback_message
+            tokens_used = 0
+            ai_metadata = {}
+        else:
+            tokens_used = openai_client.estimate_tokens(ai_response)
+            response_text, ai_metadata = parse_ai_response(ai_response)
+
+            if not ai_metadata:
+                response_text = ai_response
+                ai_metadata = {}
+            elif not response_text.strip():
+                logger.warning("⚠️ JSON найден, но текст пустой! Используем исходный ответ.")
+                response_text = ai_response
+
+            # Обновляем этап и качество
+            if ai_metadata:
+                stage = ai_metadata.get('этап')
+                quality = ai_metadata.get('качество')
+                
+                if stage or quality is not None:
+                    await supabase_client.update_session_stage(session_id, stage, quality)
+                
+                # Обрабатываем события
+                events = ai_metadata.get('события', [])
+                if events:
+                    await process_events(session_id, events, message.from_user.id)
+
+        # Сохраняем ответ ассистента
+        await supabase_client.add_message(
+            session_id=session_id,
+            role='assistant',
+            content=response_text,
+            message_type='text',
+            tokens_used=tokens_used,
+            processing_time_ms=processing_time,
+            ai_metadata=ai_metadata
+        )
+
+        # Определяем финальный ответ
+        final_response = ai_response if config.DEBUG_MODE else response_text
+        
+        if not final_response or not final_response.strip():
+            final_response = "Извините, произошла ошибка при формировании ответа. Попробуйте еще раз."
+
+        # Обрабатываем файлы
+        files_list = ai_metadata.get('файлы', [])
+        directories_list = ai_metadata.get('каталоги', [])
+        
+        # Отправляем ответ пользователю
+        await send_message(message, final_response, files_list=files_list, directories_list=directories_list)
+        logger.info(f"✅ Ответ отправлен пользователю {message.from_user.id}")
+                
+    except Exception as e:
+        logger.error(f"❌ КРИТИЧЕСКАЯ ОШИБКА в process_voice_message: {e}")
+        logger.exception("Полный стек ошибки:")
+        try:
+            await message.answer("Произошла критическая ошибка. Попробуйте написать /start")
+        except:
+            pass

smart_bot_factory/integrations/openai_client.py

@@ -432,4 +432,32 @@ class OpenAIClient:
             return [model.id for model in models.data if 'gpt' in model.id.lower()]
         except Exception as e:
             logger.error(f"Ошибка при получении списка моделей: {e}")
-            return []
+            return []
+        
+    async def transcribe_audio(self, audio_file_path: str) -> str:
+        """
+        Распознает голосовое сообщение через Whisper API
+        
+        Args:
+            audio_file_path: Путь к аудио файлу
+            
+        Returns:
+            Распознанный текст
+        """
+        try:
+            logger.info(f"🎤 Отправка аудио на распознавание: {audio_file_path}")
+            
+            with open(audio_file_path, 'rb') as audio_file:
+                transcript = await self.client.audio.transcriptions.create(
+                    model="whisper-1",
+                    file=audio_file,
+                    language="ru"  # Русский язык
+                )
+            
+            text = transcript.text
+            logger.info(f"✅ Распознано {len(text)} символов: '{text[:100]}...'")
+            return text
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка распознавания аудио: {e}")
+            return ""