Update solver_algebra.py

solver_algebra.py

@@ -34,12 +34,13 @@ def solve_algebra(text: str) -> Optional[SolverResult]:
             reply=_format_explanation_only(raw, lower, help_mode, intent),
             solved=False,
             help_mode=help_mode,
+            steps=[],
+            display_steps=[],
         )
 
     parsed = _parse_request(cleaned, lower)
     explanation = _explain_what_is_being_asked(parsed, intent)
 
-    # Route by structure
     result = (
         _handle_systems(parsed, help_mode)
         or _handle_inequality(parsed, help_mode)
@@ -56,9 +57,14 @@ def solve_algebra(text: str) -> Optional[SolverResult]:
             explanation,
             _generic_algebra_guidance(parsed, help_mode, intent),
         )
-        return _mk_result(reply=reply, solved=False, help_mode=help_mode)
+        return _mk_result(
+            reply=reply,
+            solved=False,
+            help_mode=help_mode,
+            steps=[],
+            display_steps=[],
+        )
 
-    # Prefix with decoded question meaning when useful
     if explanation:
         result.reply = _join_sections("Let’s work through it.", explanation, result.reply)
     else:
@@ -103,7 +109,7 @@ def _looks_like_algebra(raw: str, lower: str) -> bool:
 
 
 def _detect_help_mode(lower: str) -> str:
-    if any(x in lower for x in ["hint", "nudge", "small hint"]):
+    if any(x in lower for x in ["hint", "nudge", "small hint", "next hint"]):
         return "hint"
     if any(x in lower for x in ["step by step", "steps", "walkthrough", "work through"]):
         return "walkthrough"
@@ -255,6 +261,125 @@ def _degree_of_expr(expr) -> Optional[int]:
         return None
 
 
+def _safe_str(obj: Any) -> str:
+    try:
+        return str(sp.simplify(obj))
+    except Exception:
+        return str(obj)
+
+
+def _format_eq(lhs: Any, rhs: Any) -> str:
+    return f"{_safe_str(lhs)} = {_safe_str(rhs)}"
+
+
+def _strip_bullet_prefix(step: str) -> str:
+    return re.sub(r"^\s*-\s*", "", (step or "").strip())
+
+
+def _ensure_bullets(steps: List[str]) -> List[str]:
+    out = []
+    for s in steps:
+        s = _strip_bullet_prefix(s)
+        if s:
+            out.append(f"- {s}")
+    return out
+
+
+# =========================================================
+# Step builders
+# =========================================================
+
+def _build_linear_equation_steps(eq, var) -> Tuple[List[str], List[str], Optional[Any]]:
+    """
+    Returns:
+        all_steps: full internal steps including final solved step if available
+        display_steps: safe steps for walkthrough/method/answer without answer leakage
+        final_value: solved value if found
+    """
+    lhs = sp.simplify(eq.lhs)
+    rhs = sp.simplify(eq.rhs)
+
+    start_step = f"Start with {_format_eq(lhs, rhs)}."
+
+    try:
+        solutions = sp.solve(eq, var)
+    except Exception:
+        solutions = []
+
+    final_value = solutions[0] if len(solutions) == 1 else None
+
+    expr = sp.expand(lhs - rhs)
+    coeff = sp.expand(expr).coeff(var, 1)
+    const = sp.expand(expr).subs(var, 0)
+
+    all_steps: List[str] = [start_step]
+    display_steps: List[str] = [start_step]
+
+    # Pattern 1: x / c = k
+    if lhs == var / sp.denom(lhs) and rhs.is_number:
+        denom = sp.denom(lhs)
+        step2_lhs = sp.simplify(lhs * denom)
+        step2_rhs = sp.simplify(rhs * denom)
+        step2 = f"Multiply both sides by {_safe_str(denom)} to undo the division."
+        step3 = f"This gives {_format_eq(step2_lhs, step2_rhs)}."
+        all_steps.extend([step2, step3])
+        display_steps.extend([step2, step3])
+        if final_value is not None:
+            all_steps.append(f"So {_safe_str(var)} = {_safe_str(final_value)}.")
+        return _ensure_bullets(all_steps), _ensure_bullets(display_steps), final_value
+
+    # Pattern 2: a*x = b
+    try:
+        ratio = sp.simplify(lhs / var)
+        if lhs == sp.simplify(ratio * var) and ratio.is_number and ratio != 1 and rhs.is_number:
+            step2 = f"Divide both sides by {_safe_str(ratio)} to isolate {_safe_str(var)}."
+            step3 = f"This leaves {_safe_str(var)} by itself on the left."
+            all_steps.extend([step2, step3])
+            display_steps.extend([step2, step3])
+            if final_value is not None:
+                all_steps.append(f"So {_safe_str(var)} = {_safe_str(final_value)}.")
+            return _ensure_bullets(all_steps), _ensure_bullets(display_steps), final_value
+    except Exception:
+        pass
+
+    # Pattern 3: x + b = c
+    try:
+        if sp.expand(lhs).coeff(var, 1) == 1 and rhs.is_number:
+            extra = sp.simplify(lhs - var)
+            if extra.free_symbols == set():
+                if extra != 0:
+                    direction = "subtract" if extra > 0 else "add"
+                    amount = abs(extra)
+                    step2 = f"{direction.capitalize()} {_safe_str(amount)} on both sides to undo the constant term."
+                    step3 = f"That isolates {_safe_str(var)} on the left."
+                    all_steps.extend([step2, step3])
+                    display_steps.extend([step2, step3])
+                    if final_value is not None:
+                        all_steps.append(f"So {_safe_str(var)} = {_safe_str(final_value)}.")
+                    return _ensure_bullets(all_steps), _ensure_bullets(display_steps), final_value
+    except Exception:
+        pass
+
+    # General linear fallback
+    if coeff != 0:
+        if const != 0:
+            step2 = "Rearrange so the variable term is isolated."
+            step3 = "Undo the constant term using the inverse operation on both sides."
+            display_steps.extend([step2, step3])
+            all_steps.extend([step2, step3])
+        if coeff != 1:
+            step4 = f"Then divide by the coefficient of {_safe_str(var)} to isolate the variable."
+            display_steps.append(step4)
+            all_steps.append(step4)
+        if final_value is not None:
+            all_steps.append(f"So {_safe_str(var)} = {_safe_str(final_value)}.")
+    else:
+        all_steps.append("There is no variable term left after simplification, so check whether the equation is always true or impossible.")
+        display_steps.append("After simplification, check whether the statement is always true or impossible.")
+
+    return _ensure_bullets(all_steps), _ensure_bullets(display_steps), final_value
+
+
 # =========================================================
 # Handlers
 # =========================================================
@@ -271,14 +396,11 @@ def _handle_systems(parsed: Dict[str, Any], help_mode: str) -> Optional[SolverRe
         if not symbols:
             return None
 
-        lins = []
         nonlinear = []
         for eq in sym_eqs:
             expr = sp.expand(eq.lhs - eq.rhs)
             deg = _degree_of_expr(expr)
-            if deg == 1:
-                lins.append(eq)
-            else:
+            if deg != 1:
                 nonlinear.append(eq)
 
         if nonlinear:
@@ -298,9 +420,10 @@ def _handle_systems(parsed: Dict[str, Any], help_mode: str) -> Optional[SolverRe
                 ),
                 solved=True,
                 help_mode=help_mode,
+                steps=steps,
+                display_steps=steps,
             )
 
-        # Linear system classification
         matrix, vec = sp.linear_eq_to_matrix([eq.lhs - eq.rhs for eq in sym_eqs], symbols)
         rank_a = matrix.rank()
         rank_aug = matrix.row_join(vec).rank()
@@ -308,19 +431,41 @@ def _handle_systems(parsed: Dict[str, Any], help_mode: str) -> Optional[SolverRe
 
         if rank_a != rank_aug:
             msg = [
-                "This system is inconsistent.",
-                "That means the equations conflict with each other, so there is no common solution.",
-                "A good first move is to eliminate one variable and compare the resulting statements."
+                "- This system is inconsistent.",
+                "- That means the equations conflict with each other, so there is no common solution.",
+                "- A good first move is to eliminate one variable and compare the resulting statements."
             ]
-            return _mk_result(reply="\n\n".join(msg), solved=True, help_mode=help_mode)
+            return _mk_result(
+                reply=_modeled_steps(
+                    title="This system is inconsistent.",
+                    method="Eliminate a variable and compare the resulting statements.",
+                    steps=msg,
+                    help_mode=help_mode,
+                ),
+                solved=True,
+                help_mode=help_mode,
+                steps=msg,
+                display_steps=msg,
+            )
 
         if rank_a < nvars:
             msg = [
-                "This system does not pin down a unique solution.",
-                "That means there are infinitely many solutions or at least one free variable.",
-                "On GMAT-style questions, this often means you should solve for a relationship instead of individual values."
+                "- This system does not pin down a unique solution.",
+                "- That means there are infinitely many solutions or at least one free variable.",
+                "- On GMAT-style questions, this often means you should solve for a relationship instead of individual values."
             ]
-            return _mk_result(reply="\n\n".join(msg), solved=True, help_mode=help_mode)
+            return _mk_result(
+                reply=_modeled_steps(
+                    title="This system does not have a unique solution.",
+                    method="Look for a relationship rather than separate fixed values.",
+                    steps=msg,
+                    help_mode=help_mode,
+                ),
+                solved=True,
+                help_mode=help_mode,
+                steps=msg,
+                display_steps=msg,
+            )
 
         steps = [
             "- Choose one variable to eliminate.",
@@ -338,6 +483,8 @@ def _handle_systems(parsed: Dict[str, Any], help_mode: str) -> Optional[SolverRe
             ),
             solved=True,
             help_mode=help_mode,
+            steps=steps,
+            display_steps=steps,
         )
     except Exception:
         return None
@@ -356,26 +503,29 @@ def _handle_inequality(parsed: Dict[str, Any], help_mode: str) -> Optional[Solve
 
         syms = sorted(list(rel.free_symbols), key=lambda s: s.name)
         if len(syms) != 1:
+            steps = [
+                "- Collect all terms on one side.",
+                "- Factor if possible.",
+                "- Mark critical points where the expression is 0 or undefined.",
+                "- Test intervals to see where the inequality is true.",
+                "- Remember: multiplying or dividing by a negative flips the inequality sign."
+            ]
             return _mk_result(
                 reply=_modeled_steps(
                     title="This is an inequality problem.",
                     method="Rearrange so one side becomes 0, then analyze sign changes or isolate the variable.",
-                    steps=[
-                        "- Collect all terms on one side.",
-                        "- Factor if possible.",
-                        "- Mark critical points where the expression is 0 or undefined.",
-                        "- Test intervals to see where the inequality is true.",
-                        "- Remember: multiplying or dividing by a negative flips the inequality sign."
-                    ],
+                    steps=steps,
                     help_mode=help_mode,
                 ),
                 solved=True,
                 help_mode=help_mode,
+                steps=steps,
+                display_steps=steps,
             )
 
         var = syms[0]
         steps = [
-            f"- Isolate {var} as much as possible.",
+            f"- Isolate {_safe_str(var)} as much as possible.",
             "- Be careful with brackets, fractions, and negative coefficients.",
             "- If you multiply or divide by a negative quantity, reverse the inequality sign.",
             "- If the expression factors, use sign analysis instead of treating it like a normal equation."
@@ -389,6 +539,8 @@ def _handle_inequality(parsed: Dict[str, Any], help_mode: str) -> Optional[Solve
             ),
             solved=True,
             help_mode=help_mode,
+            steps=steps,
+            display_steps=steps,
         )
     except Exception:
         return None
@@ -406,10 +558,21 @@ def _handle_equation(parsed: Dict[str, Any], help_mode: str) -> Optional[SolverR
         deg = _degree_of_expr(expr)
 
         if not syms:
+            steps = [
+                "- Simplify both sides fully.",
+                "- Then decide whether the statement is always true, never true, or just a numeric identity."
+            ]
             return _mk_result(
-                reply="This expression has no variable left after simplification, so the key question is whether the statement is always true, never true, or just a numeric identity.",
+                reply=_modeled_steps(
+                    title="No variable remains after simplification.",
+                    method="Check the resulting statement itself.",
+                    steps=steps,
+                    help_mode=help_mode,
+                ),
                 solved=True,
                 help_mode=help_mode,
+                steps=steps,
+                display_steps=steps,
             )
 
         if len(syms) > 1 and deg == 1:
@@ -427,27 +590,26 @@ def _handle_equation(parsed: Dict[str, Any], help_mode: str) -> Optional[SolverR
                 ),
                 solved=True,
                 help_mode=help_mode,
+                steps=steps,
+                display_steps=steps,
             )
 
         if deg == 1:
             var = syms[0]
-            steps = [
-                "- Expand brackets if needed.",
-                "- Clear fractions or decimals if that makes the equation cleaner.",
-                f"- Collect all {var} terms on one side and constants on the other.",
-                f"- Factor out {var} if needed, then isolate it."
-            ]
-            if re.search(r"/[a-zA-Z]|\b[a-zA-Z]\s*/", parsed["raw"]):
-                steps.append("- Be careful: dividing by a variable assumes that variable is not 0.")
+            all_steps, display_steps, final_value = _build_linear_equation_steps(eq, var)
+            reply = _modeled_steps(
+                title="This is a linear equation.",
+                method="Use inverse operations and keep both sides balanced.",
+                steps=display_steps,
+                help_mode=help_mode,
+            )
             return _mk_result(
-                reply=_modeled_steps(
-                    title="This is a linear equation.",
-                    method="Use inverse operations and keep both sides balanced.",
-                    steps=steps,
-                    help_mode=help_mode,
-                ),
+                reply=reply,
                 solved=True,
                 help_mode=help_mode,
+                steps=all_steps,
+                display_steps=display_steps,
+                final_value=final_value,
             )
 
         if deg == 2:
@@ -455,8 +617,10 @@ def _handle_equation(parsed: Dict[str, Any], help_mode: str) -> Optional[SolverR
             disc = None
             try:
                 poly = sp.Poly(expr, var)
-                a, b, c = poly.all_coeffs()
-                disc = sp.expand(b**2 - 4*a*c)
+                coeffs = poly.all_coeffs()
+                if len(coeffs) == 3:
+                    a, b, c = coeffs
+                    disc = sp.expand(b**2 - 4 * a * c)
             except Exception:
                 pass
 
@@ -466,7 +630,6 @@ def _handle_equation(parsed: Dict[str, Any], help_mode: str) -> Optional[SolverR
                 "- If it does not factor cleanly, use a systematic method such as the quadratic formula or completing the square.",
                 "- After finding candidate roots internally, substitute back to verify."
             ]
-
             if disc is not None:
                 steps.append("- The discriminant tells you whether there are two, one, or no real roots.")
 
@@ -479,6 +642,8 @@ def _handle_equation(parsed: Dict[str, Any], help_mode: str) -> Optional[SolverR
                 ),
                 solved=True,
                 help_mode=help_mode,
+                steps=steps,
+                display_steps=steps,
             )
 
         if deg and deg > 2:
@@ -493,6 +658,7 @@ def _handle_equation(parsed: Dict[str, Any], help_mode: str) -> Optional[SolverR
                 steps.append("- This one appears factorable, so the zero-product idea is likely useful.")
             if parsed["has_integer_constraint"]:
                 steps.append("- Since the variables may be restricted to integers, candidate checking can also be efficient.")
+
             return _mk_result(
                 reply=_modeled_steps(
                     title="This is a higher-degree algebra equation.",
@@ -502,6 +668,8 @@ def _handle_equation(parsed: Dict[str, Any], help_mode: str) -> Optional[SolverR
                 ),
                 solved=True,
                 help_mode=help_mode,
+                steps=steps,
+                display_steps=steps,
             )
 
     except Exception:
@@ -523,74 +691,85 @@ def _handle_expression(parsed: Dict[str, Any], help_mode: str, intent: str) -> O
         expr = _sympify_expr(expr_text)
 
         if intent == "simplify":
+            steps = [
+                "- Expand only if that helps combine terms.",
+                "- Collect like powers and like variable terms.",
+                "- Factor common pieces if the expression becomes cleaner that way.",
+                "- Check for hidden identities such as a^2-b^2 or perfect squares."
+            ]
             return _mk_result(
                 reply=_modeled_steps(
                     title="This is a simplification task.",
                     method="Combine like terms, reduce fractions carefully, and use identities where helpful.",
-                    steps=[
-                        "- Expand only if that helps combine terms.",
-                        "- Collect like powers and like variable terms.",
-                        "- Factor common pieces if the expression becomes cleaner that way.",
-                        "- Check for hidden identities such as a^2-b^2 or perfect squares."
-                    ],
+                    steps=steps,
                     help_mode=help_mode,
                 ),
                 solved=True,
                 help_mode=help_mode,
+                steps=steps,
+                display_steps=steps,
             )
 
         if intent == "expand":
+            steps = [
+                "- Multiply each outside factor by each inside term.",
+                "- Watch negative signs.",
+                "- Combine like terms at the end."
+            ]
             return _mk_result(
                 reply=_modeled_steps(
                     title="This is an expansion task.",
                     method="Distribute carefully across every term in the bracket(s).",
-                    steps=[
-                        "- Multiply each outside factor by each inside term.",
-                        "- Watch negative signs.",
-                        "- Combine like terms at the end."
-                    ],
+                    steps=steps,
                     help_mode=help_mode,
                 ),
                 solved=True,
                 help_mode=help_mode,
+                steps=steps,
+                display_steps=steps,
             )
 
         if intent == "factor":
+            steps = [
+                "- Take out the greatest common factor first.",
+                "- Check for difference of squares.",
+                "- Check for perfect-square trinomials.",
+                "- If it is quadratic in form, use sum/product structure."
+            ]
             return _mk_result(
                 reply=_modeled_steps(
                     title="This is a factorization task.",
                     method="Start by pulling out any common factor, then check special identities and quadratic patterns.",
-                    steps=[
-                        "- Take out the greatest common factor first.",
-                        "- Check for difference of squares.",
-                        "- Check for perfect-square trinomials.",
-                        "- If it is quadratic in form, use sum/product structure."
-                    ],
+                    steps=steps,
                     help_mode=help_mode,
                 ),
                 solved=True,
                 help_mode=help_mode,
+                steps=steps,
+                display_steps=steps,
             )
 
         if intent == "rearrange":
+            steps = [
+                "- Identify which variable must be isolated.",
+                "- Move all target-variable terms to one side.",
+                "- Move all non-target terms to the other side.",
+                "- Factor the target variable if it appears in multiple terms.",
+                "- Divide only when you know the divisor is allowed to be nonzero."
+            ]
             return _mk_result(
                 reply=_modeled_steps(
                     title="This is a rearranging / isolating task.",
                     method="Move all terms involving the target variable together, then factor it out.",
-                    steps=[
-                        "- Identify which variable must be isolated.",
-                        "- Move all target-variable terms to one side.",
-                        "- Move all non-target terms to the other side.",
-                        "- Factor the target variable if it appears in multiple terms.",
-                        "- Divide only when you know the divisor is allowed to be nonzero."
-                    ],
+                    steps=steps,
                     help_mode=help_mode,
                 ),
                 solved=True,
                 help_mode=help_mode,
+                steps=steps,
+                display_steps=steps,
             )
 
-        # Generic expression handling
         deg = _degree_of_expr(expr)
         steps = [
             "- Decide whether the best move is simplify, expand, factor, or substitute.",
@@ -609,6 +788,8 @@ def _handle_expression(parsed: Dict[str, Any], help_mode: str, intent: str) -> O
             ),
             solved=True,
             help_mode=help_mode,
+            steps=steps,
+            display_steps=steps,
         )
     except Exception:
         return None
@@ -616,7 +797,6 @@ def _handle_expression(parsed: Dict[str, Any], help_mode: str, intent: str) -> O
 
 def _handle_word_translation(parsed: Dict[str, Any], help_mode: str) -> Optional[SolverResult]:
     lower = parsed["lower"]
-    raw = parsed["raw"]
 
     triggers = [
         "more than", "less than", "twice", "times", "sum of", "difference",
@@ -626,18 +806,18 @@ def _handle_word_translation(parsed: Dict[str, Any], help_mode: str) -> Optional
         return None
 
     mappings = [
-        ("more than", "be careful with order: '10 more than x' means x + 10"),
-        ("less than", "be careful with order: '3 less than x' means x - 3, but '3 less than a number' means number - 3"),
-        ("twice", "'twice x' means 2x"),
-        ("sum of", "'sum of a and b' means a + b"),
-        ("difference", "'difference of a and b' means a - b"),
-        ("product of", "'product of a and b' means ab"),
-        ("quotient", "'quotient of a and b' means a / b"),
-        ("at least", "this signals >= "),
-        ("at most", "this signals <= "),
-        ("no more than", "this signals <= "),
-        ("no less than", "this signals >= "),
-        ("consecutive", "use n, n+1, n+2 ..."),
+        ("more than", "Be careful with order: '10 more than x' means x + 10."),
+        ("less than", "Be careful with order: '3 less than x' means x - 3, but '3 less than a number' means number - 3."),
+        ("twice", "'Twice x' means 2x."),
+        ("sum of", "'Sum of a and b' means a + b."),
+        ("difference", "'Difference of a and b' means a - b."),
+        ("product of", "'Product of a and b' means ab."),
+        ("quotient", "'Quotient of a and b' means a / b."),
+        ("at least", "This signals >=."),
+        ("at most", "This signals <=."),
+        ("no more than", "This signals <=."),
+        ("no less than", "This signals >=."),
+        ("consecutive", "Use n, n+1, n+2, ..."),
     ]
 
     bullets = []
@@ -660,6 +840,8 @@ def _handle_word_translation(parsed: Dict[str, Any], help_mode: str) -> Optional
         ),
         solved=True,
         help_mode=help_mode,
+        steps=bullets,
+        display_steps=bullets,
     )
 
 
@@ -667,20 +849,23 @@ def _handle_degree_reasoning(parsed: Dict[str, Any], help_mode: str) -> Optional
     if not parsed["mentions_degree"]:
         return None
 
+    steps = [
+        "- Degree 1 suggests a linear structure.",
+        "- Degree 2 suggests a quadratic structure.",
+        "- Higher degree often calls for factorization, substitution, or identity spotting.",
+        "- A polynomial of degree n can have at most n roots over the reals/complexes combined."
+    ]
     return _mk_result(
         reply=_modeled_steps(
             title="This question is using degree / polynomial structure.",
             method="The degree tells you the highest power present and helps narrow the right solving method.",
-            steps=[
-                "- Degree 1 suggests a linear structure.",
-                "- Degree 2 suggests a quadratic structure.",
-                "- Higher degree often calls for factorization, substitution, or identity spotting.",
-                "- A polynomial of degree n can have at most n roots over the reals/complexes combined."
-            ],
+            steps=steps,
             help_mode=help_mode,
         ),
         solved=True,
         help_mode=help_mode,
+        steps=steps,
+        display_steps=steps,
     )
 
 
@@ -690,20 +875,23 @@ def _handle_integer_restricted(parsed: Dict[str, Any], help_mode: str) -> Option
     if not parsed["equations"] and not parsed["inequalities"]:
         return None
 
+    steps = [
+        "- Use the algebra to narrow the possible forms first.",
+        "- Then test only values consistent with the restriction.",
+        "- Stop when the restriction makes further values impossible.",
+        "- Always check the tested value in the original condition."
+    ]
     return _mk_result(
         reply=_modeled_steps(
             title="This problem has an integer restriction.",
             method="That often makes controlled testing or divisibility reasoning much faster than pure symbolic solving.",
-            steps=[
-                "- Use the algebra to narrow the possible forms first.",
-                "- Then test only values consistent with the restriction.",
-                "- Stop when the restriction makes further values impossible.",
-                "- Always check the tested value in the original condition."
-            ],
+            steps=steps,
             help_mode=help_mode,
         ),
         solved=True,
         help_mode=help_mode,
+        steps=steps,
+        display_steps=steps,
     )
 
 
@@ -760,32 +948,33 @@ def _format_explanation_only(raw: str, lower: str, help_mode: str, intent: str)
 # =========================================================
 
 def _modeled_steps(title: str, method: str, steps: List[str], help_mode: str) -> str:
+    clean_steps = _ensure_bullets(steps)
+
     if help_mode == "hint":
         return _join_sections(
             title,
             f"Hint: {method}",
-            steps[0] if steps else ""
+            clean_steps[0] if clean_steps else ""
         )
 
     if help_mode == "explain":
         return _join_sections(
             title,
             f"Method idea: {method}",
-            "\n".join(steps[:3])
+            "\n".join(clean_steps[:3])
         )
 
     if help_mode == "method":
         return _join_sections(
             title,
             f"Method: {method}",
-            "\n".join(steps)
+            "\n".join(clean_steps)
         )
 
-    # walkthrough / answer
     return _join_sections(
         title,
         f"Walkthrough method: {method}",
-        "\n".join(steps)
+        "\n".join(clean_steps)
     )
 
 
@@ -794,8 +983,18 @@ def _join_sections(*parts: str) -> str:
     return "\n\n".join(clean)
 
 
-def _mk_result(reply: str, solved: bool, help_mode: str) -> SolverResult:
-    return SolverResult(
+def _mk_result(
+    reply: str,
+    solved: bool,
+    help_mode: str,
+    steps: Optional[List[str]] = None,
+    display_steps: Optional[List[str]] = None,
+    final_value: Any = None,
+) -> SolverResult:
+    steps = steps or []
+    display_steps = display_steps or steps
+
+    result = SolverResult(
         reply=reply,
         meta={
             "domain": "quant",
@@ -806,5 +1005,31 @@ def _mk_result(reply: str, solved: bool, help_mode: str) -> SolverResult:
             "topic": "algebra",
             "used_retrieval": False,
             "used_generator": False,
+            "steps": steps,
+            "display_steps": display_steps,
+            "internal_answer": _safe_str(final_value) if final_value is not None else None,
         },
-    )
+    )
+
+    # Add attributes directly in case your formatter / conversation layer reads them.
+    try:
+        setattr(result, "steps", display_steps)
+    except Exception:
+        pass
+
+    try:
+        setattr(result, "display_steps", display_steps)
+    except Exception:
+        pass
+
+    try:
+        setattr(result, "all_steps", steps)
+    except Exception:
+        pass
+
+    try:
+        setattr(result, "internal_answer", final_value)
+    except Exception:
+        pass
+
+    return result