Spaces:
Sleeping
Sleeping
| from typing import Optional | |
| import concurrent.futures | |
| from classify_chat_helper import ( | |
| call_core_classification_llm, | |
| call_opinion_trigger_llm, | |
| call_news_formulation_llm, | |
| call_thread_match_llm, | |
| ) | |
| from classify_parameters import TRACKED_FIELDS, ALLOWED_STORY_TOPICS, TOPIC_DESCRIPTIONS | |
| from db_user import load_user_info, save_user_info, update_country | |
| from db_5_process_session import _load_history | |
| _VALID_TOPICS = set(TOPIC_DESCRIPTIONS.keys()) | |
| RECENT_HISTORY_LIMIT = 5 | |
| def analyze_message( | |
| user_id: str, | |
| query: str, | |
| character_id: str = "socrates", | |
| core_model: Optional[str] = None, | |
| opinion_model: Optional[str] = None, | |
| secondary_model: Optional[str] = None, | |
| ): | |
| """ | |
| Agent 1 (core: topic/response_mode/user_info/topic_for_tale/needs_news_fetch/needs_coverage_check) | |
| and Agent 2a (opinion-trigger, scoped to the active character) run in parallel every turn. | |
| Agent 2b (news question formulation) and Agent 2c (philosophy-thread matching) are conditional | |
| follow-ups, fired only when Agent 1's own output says they're relevant. | |
| """ | |
| # --- Load current user_info for this user --- | |
| user_info = load_user_info(user_id) | |
| profile = user_info.get("user_profile", {}) | |
| missing_fields = [f for f in ["name", "living_country", "origin_country"] if not profile.get(f)] | |
| # --- Trim history to the most recent turns --- | |
| history = _load_history("chat_history_short", user_id) | |
| all_messages = [] | |
| for session in history.get("sessions", []): | |
| all_messages.extend(session.get("messages", [])) | |
| recent_history = all_messages[-RECENT_HISTORY_LIMIT:] if all_messages else [] | |
| # --- Agent 1 + Agent 2a in parallel --- | |
| with concurrent.futures.ThreadPoolExecutor(max_workers=2) as _ex: | |
| _f_core = _ex.submit( | |
| call_core_classification_llm, query, recent_history, user_info, missing_fields, | |
| character_id=character_id, model=core_model, | |
| ) | |
| _f_opinion = _ex.submit( | |
| call_opinion_trigger_llm, query, recent_history, | |
| character_id=character_id, model=opinion_model, | |
| ) | |
| core = _f_core.result() | |
| opinion = _f_opinion.result() | |
| # Strip empty/blank values — classifier returns all fields, most empty | |
| raw_extracted = core.get("extracted_user_info", {}) | |
| extracted_info = { | |
| k: v for k, v in raw_extracted.items() | |
| if v not in (None, "", [], {}) | |
| } | |
| topic = core.get("topic", "personal") | |
| # Guard: LLM sometimes bleeds response_mode values (e.g. "dialogic") into topic. | |
| if topic not in _VALID_TOPICS: | |
| topic = "personal" | |
| response_mode = core.get("response_mode", "dialogic") | |
| topic_for_tale = core.get("topic_for_tale", "none") | |
| if topic_for_tale not in ALLOWED_STORY_TOPICS: | |
| topic_for_tale = "none" | |
| needs_news_fetch = bool(core.get("needs_news_fetch", False)) | |
| # --- Agent 2b — conditional: news question formulation --- | |
| news_topic, news_question, news_temporal_context = [], "", "" | |
| if needs_news_fetch: | |
| news = call_news_formulation_llm(query, recent_history, model=secondary_model) | |
| news_topic = news.get("news_topic", []) | |
| news_question = news.get("news_question", "") | |
| news_temporal_context = news.get("news_temporal_context", "") | |
| # --- Agent 2c — conditional: philosophy-thread matching --- | |
| philosophy_thread_index, philosophy_depth_requested = -1, "" | |
| if response_mode == "philosophy_thread": | |
| thread = call_thread_match_llm(query, recent_history, character_id=character_id, model=secondary_model) | |
| philosophy_thread_index = thread.get("philosophy_thread_index", -1) | |
| philosophy_depth_requested = thread.get("philosophy_depth_requested", "") or "" | |
| # --- Update user_info in Supabase only when genuinely new info was extracted --- | |
| if extracted_info: | |
| _prev_living = profile.get("living_country", "") | |
| _prev_origin = profile.get("origin_country", "") | |
| profile.update(extracted_info) | |
| user_info["user_profile"] = profile | |
| save_user_info(user_info, user_id) | |
| # Only update countries when the LLM extracted a value that differs from what was stored | |
| if "living_country" in extracted_info and extracted_info["living_country"] != _prev_living: | |
| update_country("living", extracted_info["living_country"], user_id) | |
| if "origin_country" in extracted_info and extracted_info["origin_country"] != _prev_origin: | |
| update_country("origin", extracted_info["origin_country"], user_id) | |
| return { | |
| "topic": topic, | |
| "response_mode": response_mode, | |
| "user_info": user_info, | |
| "relevant_missing": missing_fields, | |
| "topic_for_tale": topic_for_tale, | |
| "chunks": [], | |
| "needs_news_fetch": needs_news_fetch, | |
| "news_topic": news_topic, | |
| "news_question": news_question, | |
| "news_temporal_context": news_temporal_context, | |
| "socratic_trigger": opinion.get("socratic_trigger", "none") or "none", | |
| "trigger_subtype": opinion.get("trigger_subtype", "") or "", | |
| "socratic_alignment": opinion.get("socratic_alignment", "none") or "none", | |
| "needs_coverage_check": bool(core.get("needs_coverage_check", False)), | |
| "philosophy_thread_index": philosophy_thread_index, | |
| "philosophy_depth_requested": philosophy_depth_requested, | |
| } | |