Update conversation_logic.py

conversation_logic.py

@@ -35,64 +35,26 @@ DIRECT_SOLVE_PATTERNS = [
 
 STRUCTURE_KEYWORDS = {
     "algebra": [
-        "equation",
-        "solve",
-        "isolate",
-        "variable",
-        "linear",
-        "expression",
-        "unknown",
-        "algebra",
-        "substitute",
-        "rearrange",
+        "equation", "solve", "isolate", "variable", "linear", "expression",
+        "unknown", "algebra", "substitute", "rearrange"
     ],
     "percent": [
-        "percent",
-        "%",
-        "percentage",
-        "increase",
-        "decrease",
-        "of",
+        "percent", "%", "percentage", "increase", "decrease", "of"
     ],
     "ratio": [
-        "ratio",
-        "proportion",
-        "proportional",
-        "part",
-        "share",
+        "ratio", "proportion", "proportional", "part", "share"
     ],
     "statistics": [
-        "mean",
-        "median",
-        "mode",
-        "range",
-        "average",
-        "standard deviation",
+        "mean", "median", "mode", "range", "average", "standard deviation"
     ],
     "probability": [
-        "probability",
-        "chance",
-        "likely",
-        "odds",
-        "event",
+        "probability", "chance", "likely", "odds", "event"
     ],
     "geometry": [
-        "triangle",
-        "circle",
-        "angle",
-        "area",
-        "perimeter",
-        "radius",
-        "diameter",
+        "triangle", "circle", "angle", "area", "perimeter", "radius", "diameter"
     ],
     "number_properties": [
-        "integer",
-        "odd",
-        "even",
-        "prime",
-        "divisible",
-        "factor",
-        "multiple",
+        "integer", "odd", "even", "prime", "divisible", "factor", "multiple"
     ],
 }
 
@@ -109,45 +71,26 @@ INTENT_KEYWORDS = {
 
 MISMATCH_TERMS = {
     "algebra": [
-        "absolute value",
-        "modulus",
-        "square root",
-        "quadratic",
-        "inequality",
-        "roots",
-        "parabola",
-        "simultaneous equations",
+        "absolute value", "modulus", "square root", "quadratic", "inequality",
+        "roots", "parabola", "simultaneous equations"
     ],
     "percent": [
-        "triangle",
-        "circle",
-        "prime",
-        "absolute value",
+        "triangle", "circle", "prime", "absolute value"
     ],
     "ratio": [
-        "absolute value",
-        "quadratic",
-        "circle",
+        "absolute value", "quadratic", "circle"
     ],
     "statistics": [
-        "absolute value",
-        "prime",
-        "triangle",
+        "absolute value", "prime", "triangle"
     ],
     "probability": [
-        "absolute value",
-        "circle area",
-        "quadratic",
+        "absolute value", "circle area", "quadratic"
     ],
     "geometry": [
-        "absolute value",
-        "prime",
-        "median salary",
+        "absolute value", "prime", "median salary"
     ],
     "number_properties": [
-        "circle",
-        "triangle",
-        "absolute value",
+        "circle", "triangle", "absolute value"
     ],
 }
 
@@ -361,7 +304,7 @@ def _build_retrieval_query(
 ) -> str:
     parts: List[str] = []
 
-    base = question_text.strip() if (question_text or "").strip() else (raw_user_text or "").strip()
+    base = (question_text or "").strip() or (raw_user_text or "").strip()
     if base:
         parts.append(base)
 
@@ -382,144 +325,15 @@ def _build_retrieval_query(
     return " ".join(parts).strip()
 
 
-def generate_response(
-    raw_user_text: str,
-    tone: float = 0.5,
-    verbosity: float = 0.5,
-    transparency: float = 0.5,
-    retrieval_engine: Optional[RetrievalEngine] = None,
-    generator_engine: Optional[GeneratorEngine] = None,
-    retrieval_context: Optional[List[RetrievedChunk]] = None,
-    chat_history: Optional[List[Dict[str, Any]]] = None,
-    question_text: Optional[str] = None,
-) -> Dict[str, Any]:
-    solver_input = (question_text or raw_user_text or "").strip()
-    user_text = (raw_user_text or "").strip()
-
-    intent = detect_intent(user_text)
-    help_mode = intent_to_help_mode(intent)
-    reveal_answer = help_mode == "answer" or transparency >= 0.8
-
-    result = SolverResult(
-        domain="general",
-        solved=False,
-        help_mode=help_mode,
-        answer_letter=None,
-        answer_value=None,
-        topic=None,
-        used_retrieval=False,
-        used_generator=False,
-        internal_answer=None,
-        steps=[],
-        teaching_chunks=[],
-        meta={},
-    )
-
-    selected_chunks: List[RetrievedChunk] = []
-
-    if is_quant_question(solver_input):
-        result = solve_quant(solver_input)
-        if not result.help_mode:
-            result.help_mode = help_mode
-
-    reply = _compose_quant_reply(
-        result=result,
-        intent=intent,
-        reveal_answer=reveal_answer,
-        verbosity=verbosity,
-    )
-
-    allow_retrieval = should_retrieve(
-        intent=intent,
-        solved=bool(result.solved),
-        raw_user_text=user_text or solver_input,
-    )
-
-    if allow_retrieval and retrieval_context:
-        filtered = _filter_retrieved_chunks(
-            chunks=retrieval_context,
-            intent=intent,
-            topic=result.topic,
-            question_text=solver_input,
-        )
-        if filtered:
-            selected_chunks = filtered
-            result.used_retrieval = True
-            result.teaching_chunks = filtered
-
-    elif allow_retrieval and retrieval_engine is not None:
-        query = _build_retrieval_query(
-            raw_user_text=user_text,
-            question_text=solver_input,
-            intent=intent,
-            topic=result.topic,
-            solved=bool(result.solved),
-        )
-        retrieved = retrieval_engine.search(query, top_k=6)
-        filtered = _filter_retrieved_chunks(
-            chunks=retrieved,
-            intent=intent,
-            topic=result.topic,
-            question_text=solver_input,
-        )
-        if filtered:
-            selected_chunks = filtered
-            result.used_retrieval = True
-            result.teaching_chunks = filtered
-
-    if selected_chunks:
-        reply = f"{reply}\n\nRelevant study notes:\n" + "\n".join(_teaching_lines(selected_chunks))
-
-    if not result.solved and generator_engine is not None:
-        try:
-            generated = generator_engine.generate(
-                user_text=user_text or solver_input,
-                intent=intent,
-                topic=result.topic,
-                chat_history=chat_history or [],
-            )
-            if generated and generated.strip():
-                reply = generated.strip()
-                result.used_generator = True
-        except Exception:
-            pass
-
-    reply = format_reply(
-        text=reply,
-        tone=tone,
-        verbosity=verbosity,
-        transparency=transparency,
-    )
-
-    result.reply = short_lines(reply)
-    result.help_mode = help_mode
-
-    return {
-        "reply": result.reply,
-        "meta": {
-            "domain": result.domain,
-            "solved": result.solved,
-            "help_mode": result.help_mode,
-            "answer_letter": result.answer_letter,
-            "answer_value": result.answer_value,
-            "topic": result.topic,
-            "used_retrieval": result.used_retrieval,
-            "used_generator": result.used_generator,
-        },
-    }
-
-
 class ConversationEngine:
     def __init__(
         self,
         retriever: Optional[RetrievalEngine] = None,
         generator: Optional[GeneratorEngine] = None,
-        retrieval_engine: Optional[RetrievalEngine] = None,
-        generator_engine: Optional[GeneratorEngine] = None,
         **kwargs,
     ) -> None:
-        self.retrieval_engine = retrieval_engine or retriever
-        self.generator_engine = generator_engine or generator
+        self.retriever = retriever
+        self.generator = generator
 
     def generate_response(
         self,
@@ -527,66 +341,117 @@ class ConversationEngine:
         tone: float = 0.5,
         verbosity: float = 0.5,
         transparency: float = 0.5,
+        intent: Optional[str] = None,
+        help_mode: Optional[str] = None,
         retrieval_context: Optional[List[RetrievedChunk]] = None,
         chat_history: Optional[List[Dict[str, Any]]] = None,
         question_text: Optional[str] = None,
-        message: Optional[str] = None,
-        prompt: Optional[str] = None,
-        query: Optional[str] = None,
-        text: Optional[str] = None,
-        user_message: Optional[str] = None,
+        options_text: Optional[List[str]] = None,
         **kwargs,
-    ) -> Dict[str, Any]:
-        resolved_text = (
-            raw_user_text
-            or message
-            or prompt
-            or query
-            or text
-            or user_message
-            or ""
+    ) -> SolverResult:
+        solver_input = (question_text or raw_user_text or "").strip()
+        user_text = (raw_user_text or "").strip()
+
+        resolved_intent = intent or detect_intent(user_text, help_mode)
+        resolved_help_mode = help_mode or intent_to_help_mode(resolved_intent)
+        reveal_answer = resolved_help_mode == "answer" or transparency >= 0.8
+
+        result = SolverResult(
+            domain="general",
+            solved=False,
+            help_mode=resolved_help_mode,
+            answer_letter=None,
+            answer_value=None,
+            topic=None,
+            used_retrieval=False,
+            used_generator=False,
+            internal_answer=None,
+            steps=[],
+            teaching_chunks=[],
+            meta={},
         )
 
-        return generate_response(
-            raw_user_text=resolved_text,
-            tone=tone,
+        selected_chunks: List[RetrievedChunk] = []
+
+        if is_quant_question(solver_input):
+            result = solve_quant(solver_input)
+            result.help_mode = resolved_help_mode
+
+        reply = _compose_quant_reply(
+            result=result,
+            intent=resolved_intent,
+            reveal_answer=reveal_answer,
             verbosity=verbosity,
-            transparency=transparency,
-            retrieval_engine=self.retrieval_engine,
-            generator_engine=self.generator_engine,
-            retrieval_context=retrieval_context,
-            chat_history=chat_history,
-            question_text=question_text,
         )
 
-    def __call__(
-        self,
-        raw_user_text: Optional[str] = None,
-        tone: float = 0.5,
-        verbosity: float = 0.5,
-        transparency: float = 0.5,
-        retrieval_context: Optional[List[RetrievedChunk]] = None,
-        chat_history: Optional[List[Dict[str, Any]]] = None,
-        question_text: Optional[str] = None,
-        message: Optional[str] = None,
-        prompt: Optional[str] = None,
-        query: Optional[str] = None,
-        text: Optional[str] = None,
-        user_message: Optional[str] = None,
-        **kwargs,
-    ) -> Dict[str, Any]:
-        return self.generate_response(
-            raw_user_text=raw_user_text,
+        allow_retrieval = should_retrieve(
+            intent=resolved_intent,
+            solved=bool(result.solved),
+            raw_user_text=user_text or solver_input,
+        )
+
+        if allow_retrieval and retrieval_context:
+            filtered = _filter_retrieved_chunks(
+                chunks=retrieval_context,
+                intent=resolved_intent,
+                topic=result.topic,
+                question_text=solver_input,
+            )
+            if filtered:
+                selected_chunks = filtered
+                result.used_retrieval = True
+                result.teaching_chunks = filtered
+
+        elif allow_retrieval and self.retriever is not None:
+            query = _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,
+                topic=result.topic,
+                question_text=solver_input,
+            )
+            if filtered:
+                selected_chunks = filtered
+                result.used_retrieval = True
+                result.teaching_chunks = filtered
+
+        if selected_chunks:
+            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
+
+        reply = format_reply(
+            text=reply,
             tone=tone,
             verbosity=verbosity,
             transparency=transparency,
-            retrieval_context=retrieval_context,
-            chat_history=chat_history,
-            question_text=question_text,
-            message=message,
-            prompt=prompt,
-            query=query,
-            text=text,
-            user_message=user_message,
-            **kwargs,
-        )
+        )
+
+        result.reply = short_lines(reply)
+        result.help_mode = resolved_help_mode
+        result.meta = {
+            "intent": resolved_intent,
+            "question_text": question_text or "",
+            "options_count": len(options_text or []),
+        }
+
+        return result