Update conversation_logic.py

conversation_logic.py

@@ -38,24 +38,12 @@ STRUCTURE_KEYWORDS = {
         "equation", "solve", "isolate", "variable", "linear", "expression",
         "unknown", "algebra", "substitute", "rearrange"
     ],
-    "percent": [
-        "percent", "%", "percentage", "increase", "decrease", "of"
-    ],
-    "ratio": [
-        "ratio", "proportion", "proportional", "part", "share"
-    ],
-    "statistics": [
-        "mean", "median", "mode", "range", "average", "standard deviation"
-    ],
-    "probability": [
-        "probability", "chance", "likely", "odds", "event"
-    ],
-    "geometry": [
-        "triangle", "circle", "angle", "area", "perimeter", "radius", "diameter"
-    ],
-    "number_properties": [
-        "integer", "odd", "even", "prime", "divisible", "factor", "multiple"
-    ],
+    "percent": ["percent", "%", "percentage", "increase", "decrease", "of"],
+    "ratio": ["ratio", "proportion", "proportional", "part", "share"],
+    "statistics": ["mean", "median", "mode", "range", "average", "standard deviation"],
+    "probability": ["probability", "chance", "likely", "odds", "event"],
+    "geometry": ["triangle", "circle", "angle", "area", "perimeter", "radius", "diameter"],
+    "number_properties": ["integer", "odd", "even", "prime", "divisible", "factor", "multiple"],
 }
 
 INTENT_KEYWORDS = {
@@ -74,24 +62,12 @@ MISMATCH_TERMS = {
         "absolute value", "modulus", "square root", "quadratic", "inequality",
         "roots", "parabola", "simultaneous equations"
     ],
-    "percent": [
-        "triangle", "circle", "prime", "absolute value"
-    ],
-    "ratio": [
-        "absolute value", "quadratic", "circle"
-    ],
-    "statistics": [
-        "absolute value", "prime", "triangle"
-    ],
-    "probability": [
-        "absolute value", "circle area", "quadratic"
-    ],
-    "geometry": [
-        "absolute value", "prime", "median salary"
-    ],
-    "number_properties": [
-        "circle", "triangle", "absolute value"
-    ],
+    "percent": ["triangle", "circle", "prime", "absolute value"],
+    "ratio": ["absolute value", "quadratic", "circle"],
+    "statistics": ["absolute value", "prime", "triangle"],
+    "probability": ["absolute value", "circle area", "quadratic"],
+    "geometry": ["absolute value", "prime", "median salary"],
+    "number_properties": ["circle", "triangle", "absolute value"],
 }
 
 
@@ -255,8 +231,7 @@ def _score_chunk(
         elif topic.lower() in text:
             score += 2.0
 
-    structure_terms = _infer_structure_terms(question_text, topic)
-    for term in structure_terms:
+    for term in _infer_structure_terms(question_text, topic):
         if term.lower() in text:
             score += 1.5
 
@@ -268,8 +243,7 @@ def _score_chunk(
     overlap = sum(1 for kw in q_keywords if kw in text)
     score += min(overlap * 0.4, 3.0)
 
-    mismatch_terms = _infer_mismatch_terms(topic, question_text)
-    for bad in mismatch_terms:
+    for bad in _infer_mismatch_terms(topic, question_text):
         if bad.lower() in text:
             score -= 2.5
 
@@ -325,6 +299,78 @@ def _build_retrieval_query(
     return " ".join(parts).strip()
 
 
+def _to_chunk(item: Any) -> Optional[RetrievedChunk]:
+    if isinstance(item, RetrievedChunk):
+        return item
+
+    if isinstance(item, dict):
+        return RetrievedChunk(
+            text=str(item.get("text", "")).strip(),
+            topic=str(item.get("topic", "general")).strip() or "general",
+            source=str(item.get("source", "local")).strip() or "local",
+            score=float(item.get("score", 0.0) or 0.0),
+        )
+
+    if isinstance(item, str):
+        txt = item.strip()
+        if txt:
+            return RetrievedChunk(text=txt)
+
+    return None
+
+
+def _retrieve_chunks(retriever: Any, query: str) -> List[RetrievedChunk]:
+    raw = None
+
+    try:
+        raw = retriever.search(query, top_k=6)
+    except TypeError:
+        try:
+            raw = retriever.search(query)
+        except Exception:
+            raw = None
+    except Exception:
+        raw = None
+
+    if raw is None:
+        for method_name in ["retrieve", "run", "query"]:
+            method = getattr(retriever, method_name, None)
+            if callable(method):
+                try:
+                    raw = method(query)
+                    break
+                except Exception:
+                    raw = None
+
+    if raw is None:
+        return []
+
+    if not isinstance(raw, list):
+        raw = [raw]
+
+    out: List[RetrievedChunk] = []
+    for item in raw:
+        chunk = _to_chunk(item)
+        if chunk and chunk.text:
+            out.append(chunk)
+    return out
+
+
+def _generate_fallback(generator: Any, user_text: str, intent: str, topic: Optional[str], chat_history: List[Dict[str, Any]]) -> Optional[str]:
+    for call in [
+        lambda: generator.generate(user_text=user_text, intent=intent, topic=topic, chat_history=chat_history),
+        lambda: generator.generate(user_text, intent=intent, topic=topic, chat_history=chat_history),
+        lambda: generator.generate(user_text),
+    ]:
+        try:
+            result = call()
+            if isinstance(result, str) and result.strip():
+                return result.strip()
+        except Exception:
+            continue
+    return None
+
+
 class ConversationEngine:
     def __init__(
         self,
@@ -374,7 +420,9 @@ class ConversationEngine:
         selected_chunks: List[RetrievedChunk] = []
 
         if is_quant_question(solver_input):
-            result = solve_quant(solver_input)
+            solved_result = solve_quant(solver_input)
+            if solved_result is not None:
+                result = solved_result
             result.help_mode = resolved_help_mode
 
         reply = _compose_quant_reply(
@@ -391,8 +439,10 @@ class ConversationEngine:
         )
 
         if allow_retrieval and retrieval_context:
+            safe_chunks = [_to_chunk(c) for c in retrieval_context]
+            safe_chunks = [c for c in safe_chunks if c and c.text]
             filtered = _filter_retrieved_chunks(
-                chunks=retrieval_context,
+                chunks=safe_chunks,
                 intent=resolved_intent,
                 topic=result.topic,
                 question_text=solver_input,
@@ -403,14 +453,13 @@ class ConversationEngine:
                 result.teaching_chunks = filtered
 
         elif allow_retrieval and self.retriever is not None:
-            query = _build_retrieval_query(
+            retrieved = _retrieve_chunks(self.retriever, _build_retrieval_query(
                 raw_user_text=user_text,
                 question_text=solver_input,
                 intent=resolved_intent,
                 topic=result.topic,
                 solved=bool(result.solved),
-            )
-            retrieved = self.retriever.search(query, top_k=6)
+            ))
             filtered = _filter_retrieved_chunks(
                 chunks=retrieved,
                 intent=resolved_intent,
@@ -426,18 +475,16 @@ class ConversationEngine:
             reply = f"{reply}\n\nRelevant study notes:\n" + "\n".join(_teaching_lines(selected_chunks))
 
         if not result.solved and self.generator is not None:
-            try:
-                generated = self.generator.generate(
-                    user_text=user_text or solver_input,
-                    intent=resolved_intent,
-                    topic=result.topic,
-                    chat_history=chat_history or [],
-                )
-                if generated and generated.strip():
-                    reply = generated.strip()
-                    result.used_generator = True
-            except Exception:
-                pass
+            generated = _generate_fallback(
+                generator=self.generator,
+                user_text=user_text or solver_input,
+                intent=resolved_intent,
+                topic=result.topic,
+                chat_history=chat_history or [],
+            )
+            if generated:
+                reply = generated
+                result.used_generator = True
 
         reply = format_reply(
             text=reply,