Add /api/alter OpenAI increase decrease

src/deploy/backend/app/main.py

@@ -10,6 +10,8 @@ from fastapi.middleware.cors import CORSMiddleware
 
 from app.config import CORS_ORIGINS, MODEL_PATH
 from app.schemas import (
+    AlterComplexityRequest,
+    AlterComplexityResponse,
     EfficiencyRequest,
     EfficiencyResponse,
     HealthResponse,
@@ -133,3 +135,37 @@ def api_intervene_all(body: InterveneAllRequest):
 @app.post("/api/efficiency", response_model=EfficiencyResponse)
 def api_efficiency(body: EfficiencyRequest):
     return compare_efficiency(body.sentence.strip(), body.target_word.strip(), body.local_latency_ms)
+
+
+@app.post("/api/alter", response_model=AlterComplexityResponse)
+def api_alter(body: AlterComplexityRequest):
+    from reason_interventions import alter_complexity
+
+    try:
+        result = alter_complexity(
+            body.reason,
+            body.sentence.strip(),
+            body.target_word.strip(),
+            body.direction,
+        )
+    except RuntimeError as exc:
+        raise HTTPException(status_code=503, detail=str(exc)) from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    if result.reason == "Lexical Rarity":
+        updates = "Updated sentence and target word above — click Predict again."
+    else:
+        updates = "Updated sentence above (target word unchanged) — click Predict again."
+
+    return AlterComplexityResponse(
+        reason=result.reason,
+        direction=result.direction,
+        original_sentence=result.original_sentence,
+        original_target_word=result.original_target,
+        new_sentence=result.new_sentence,
+        new_target_word=result.new_target,
+        edit_method=result.edit_method,
+        explanation=result.explanation,
+        updates=updates,
+    )

src/deploy/backend/app/schemas.py

@@ -77,3 +77,22 @@ class HealthResponse(BaseModel):
     model_path: str
     model_ready: bool
     model_error: str | None = None
+
+
+class AlterComplexityRequest(BaseModel):
+    sentence: str = Field(..., min_length=1)
+    target_word: str = Field(..., min_length=1)
+    reason: str = Field(..., min_length=1)
+    direction: str = Field(..., pattern="^(increase|decrease)$")
+
+
+class AlterComplexityResponse(BaseModel):
+    reason: str
+    direction: str
+    original_sentence: str
+    original_target_word: str
+    new_sentence: str
+    new_target_word: str
+    edit_method: str
+    explanation: str
+    updates: str

src/reason_interventions.py

@@ -130,3 +130,127 @@ def apply_intervention(reason: str, sentence: str, target_word: str, use_llm: bo
 
 def apply_all_interventions(sentence: str, target_word: str, use_llm: bool = True) -> list[InterventionResult]:
     return [fn(sentence, target_word, use_llm=use_llm) for fn in EDIT_FNS.values()]
+
+
+@dataclass
+class AlterComplexityResult:
+    reason: str
+    direction: str  # "increase" | "decrease"
+    original_sentence: str
+    original_target: str
+    new_sentence: str
+    new_target: str
+    edit_method: str
+    explanation: str
+
+
+def _require_llm(prompt: str) -> tuple[str, str]:
+    text, method = _call_llm(prompt)
+    if not text or method == "rule":
+        raise RuntimeError(
+            "OpenAI edit failed. Set OPENAI_API_KEY on the backend (HF Space secrets)."
+        )
+    return text, method
+
+
+def _parse_json_block(raw: str) -> dict:
+    import json
+    import re
+
+    raw = raw.strip()
+    if raw.startswith("```"):
+        raw = re.sub(r"^```(?:json)?\s*", "", raw)
+        raw = re.sub(r"\s*```$", "", raw)
+    return json.loads(raw)
+
+
+def alter_complexity(
+    reason: str,
+    sentence: str,
+    target_word: str,
+    direction: str,
+) -> AlterComplexityResult:
+    """User-guided edit: increase or decrease one complexity dimension via OpenAI."""
+    if reason not in EDIT_FNS:
+        raise ValueError(f"Unknown reason: {reason}. Choose from {REASON_ORDER}")
+    if direction not in ("increase", "decrease"):
+        raise ValueError("direction must be 'increase' or 'decrease'")
+
+    if reason == "Lexical Rarity":
+        if direction == "decrease":
+            task = (
+                f"Replace ONLY '{target_word}' with a MORE COMMON, simpler synonym "
+                f"(same meaning and part of speech). Keep the rest of the sentence unchanged."
+            )
+        else:
+            task = (
+                f"Replace ONLY '{target_word}' with a RARER, more formal or technical synonym "
+                f"(same meaning and part of speech). Keep the rest of the sentence unchanged."
+            )
+        prompt = (
+            f"{task}\n"
+            f"Sentence: {sentence}\n"
+            f"Target word: {target_word}\n"
+            f'Return ONLY valid JSON: {{"sentence": "full sentence with new word", '
+            f'"target_word": "the new target word", "explanation": "one short sentence"}}'
+        )
+        raw, method = _require_llm(prompt)
+        data = _parse_json_block(raw)
+        new_sentence = str(data["sentence"]).strip()
+        new_target = str(data["target_word"]).strip()
+        explanation = str(data.get("explanation", "Lexical rarity adjusted."))
+    elif reason == "Contextual Ambiguity":
+        if direction == "decrease":
+            task = (
+                f"Rewrite the sentence so the meaning of '{target_word}' is CLEARER and less ambiguous. "
+                f"You MUST keep the exact word '{target_word}' unchanged (same spelling)."
+            )
+        else:
+            task = (
+                f"Rewrite the sentence so '{target_word}' is MORE AMBIGUOUS in context "
+                f"(multiple plausible meanings). You MUST keep the exact word '{target_word}' unchanged."
+            )
+        prompt = (
+            f"{task}\n"
+            f"Sentence: {sentence}\n"
+            f'Return ONLY valid JSON: {{"sentence": "new sentence", '
+            f'"explanation": "one short sentence"}}'
+        )
+        raw, method = _require_llm(prompt)
+        data = _parse_json_block(raw)
+        new_sentence = str(data["sentence"]).strip()
+        new_target = target_word
+        explanation = str(data.get("explanation", "Contextual ambiguity adjusted."))
+    else:  # Syntactic Complexity
+        if direction == "decrease":
+            task = (
+                f"Simplify the sentence structure to plain, short English. "
+                f"You MUST keep the exact word '{target_word}' unchanged."
+            )
+        else:
+            task = (
+                f"Make the sentence syntactically MORE COMPLEX (subordinate clauses, passive, etc.). "
+                f"You MUST keep the exact word '{target_word}' unchanged."
+            )
+        prompt = (
+            f"{task}\n"
+            f"Sentence: {sentence}\n"
+            f'Return ONLY valid JSON: {{"sentence": "new sentence", '
+            f'"explanation": "one short sentence"}}'
+        )
+        raw, method = _require_llm(prompt)
+        data = _parse_json_block(raw)
+        new_sentence = str(data["sentence"]).strip()
+        new_target = target_word
+        explanation = str(data.get("explanation", "Syntactic complexity adjusted."))
+
+    return AlterComplexityResult(
+        reason=reason,
+        direction=direction,
+        original_sentence=sentence,
+        original_target=target_word,
+        new_sentence=new_sentence,
+        new_target=new_target,
+        edit_method=method,
+        explanation=explanation,
+    )