eq-layer 0.1.0__py3-none-any.whl

eq_layer/affect.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Iterable, Protocol
+
+from .policies import AffectState
+
+
+class AffectAdapter(Protocol):
+    name: str
+
+    def infer(
+        self,
+        messages: list[dict],
+        turn_index: int = 0,
+        annotated: dict | None = None,
+    ) -> AffectState: ...
+
+
+# --- detectors -----------------------------------------------------------
+# Keyword sets are a stand-in for a trained classifier. They are deliberately
+# small and readable: when one of them is wrong you can see why without a
+# gradient.
+
+ESCALATION_MARKERS = (
+    "neden",
+    "sen de",
+    "saçmalama",
+    "yine",
+    "kaç kez",
+    "kaç defa",
+    "anlamıyorsun",
+    "sinir",
+    "rezalet",
+)
+
+SOFTENERS = (
+    "galiba",
+    "aslında",
+    "belki",
+    "biraz",
+    "emin değilim",
+    "kısmen",
+)
+
+CORRECTION_MARKERS = (
+    "hayır, onu demedim",
+    "hayır onu demedim",
+    "öyle değil",
+    "yanlış anladın",
+    "yanlış anladınız",
+    "onu sormadım",
+    "ben onu demedim",
+    "demek istediğim",
+    "kastettiğim",
+    "that's not what i meant",
+    "you misunderstood",
+    "no, i meant",
+    "i didn't say that",
+    "i said",
+    "i meant",
+    "meant to say",
+    "that doesn't work",
+    "that does not work",
+    "that doesn’t work",
+    "that's wrong",
+    "that is wrong",
+)
+
+DISCLOSURE_MARKERS = (
+    "kimseye anlatma",
+    "kimseye söyleme",
+    "sır",
+    "gizli tut",
+    "benden başka kimse",
+)
+
+# A user opening consecutive turns with a wh-word is asking the same thing
+# again. That is interrogation, not curiosity — and the register has to change.
+QUESTION_OPENERS = ("ne", "neden", "niçin", "nasıl", "nedir", "hangi", "kaç", "mı", "mi")
+
+
+@dataclass
+class HeuristicAffect:
+    name: str = "heuristic"
+
+    # --- arousal ----------------------------------------------------------
+
+    def _arousal(self, text: str) -> float:
+        if not text:
+            return 0.0
+        low = text.lower().strip()
+        hits = sum(1 for m in ESCALATION_MARKERS if m in low)
+        softens = sum(1 for s in SOFTENERS if s in low)
+        score = min(1.0, 0.25 + hits * 0.22 - softens * 0.12)
+        if "?" in low or "!" in low:
+            score = min(1.0, score + 0.1)
+        return round(score, 3)
+
+    def _has(self, text: str, markers: Iterable[str]) -> bool:
+        low = text.lower()
+        return any(m in low for m in markers)
+
+    # --- structural signals ----------------------------------------------
+
+    def _recent_user_turns(self, messages: list[dict], n: int = 4) -> list[str]:
+        turns = [m["content"] for m in messages if m.get("role") == "user"]
+        return turns[-n:]
+
+    def _escalating(self, user_turns: list[str]) -> bool:
+        """Three or more consecutive turns opening with a wh-word."""
+        if len(user_turns) < 3:
+            return False
+        return all(
+            self._first_word(t) in QUESTION_OPENERS for t in user_turns[-3:] if t.strip()
+        )
+
+    def _first_word(self, text: str) -> str:
+        """First token with punctuation stripped. 'Neden?' must match 'neden',
+        otherwise a bare one-word question — the shape this is built to
+        detect — silently fails."""
+        token = text.lower().strip().split()[0]
+        return token.strip("?!.,;:")
+
+    def _demand_pattern(self, user_turns: list[str]) -> bool:
+        """Short imperative demands, stacked. 'Anlat biçim!' repeated."""
+        recent = [t for t in user_turns[-3:] if t.strip()]
+        if len(recent) < 3:
+            return False
+        short = all(len(t.split()) <= 5 for t in recent)
+        punctuated = sum(1 for t in recent if t.strip().endswith(("?", "!"))) >= 2
+        return short and punctuated
+
+    def _high_arousal_run(self, user_turns: list[str]) -> bool:
+        return len(user_turns) >= 2 and all(self._arousal(t) >= 0.5 for t in user_turns[-2:])
+
+    # --- subtext ----------------------------------------------------------
+
+    def _subtext(
+        self,
+        user_turns: list[str],
+        annotated: dict,
+        has_prior_assistant: bool = False,
+    ) -> str:
+        current = user_turns[-1] if user_turns else ""
+        low = current.lower()
+
+        if has_prior_assistant and self._has(current, CORRECTION_MARKERS):
+            return "correction"
+        if self._has(current, DISCLOSURE_MARKERS):
+            return "disclosure_request"
+        if annotated.get("subtext") in {"exhaustion", "resignation"}:
+            return annotated["subtext"]
+        if self._escalating(user_turns):
+            return "escalating"
+        if self._demand_pattern(user_turns):
+            return "demand"
+
+        stripped = current.rstrip()
+        if stripped.endswith("?") and not self._has(current, ESCALATION_MARKERS):
+            return "question"
+        if stripped.endswith(("!", "?")) or self._has(current, ESCALATION_MARKERS):
+            return "challenge"
+        return "statement"
+
+    def _stance(self, current: str, annotated: dict) -> str:
+        """Whether the user is in the right. Not inferable from keywords —
+        this is a semantic judgement, so it defaults to unknown and expects an
+        annotation. Guessing here is how a layer starts confidently wrong."""
+        return annotated.get("stance", "unknown")
+
+    # --- entry point ------------------------------------------------------
+
+    def infer(
+        self,
+        messages: list[dict],
+        turn_index: int = 0,
+        annotated: dict | None = None,
+    ) -> AffectState:
+        annotated = annotated or {}
+        user_turns = [m["content"] for m in messages if m.get("role") == "user"]
+
+        history = self._history(user_turns)
+        current = user_turns[-1] if user_turns else ""
+        previous = user_turns[-2] if len(user_turns) > 1 else ""
+        arousal = self._arousal(current)
+
+        return AffectState(
+            valence=round(0.5 - arousal, 3),
+            arousal=arousal,
+            escalation_delta=round(arousal - self._arousal(previous), 3) if previous else 0.0,
+            stance=self._stance(current, annotated),
+            subtext=self._subtext(
+                user_turns,
+                annotated,
+                has_prior_assistant=any(
+                    m.get("role") == "assistant" for m in messages[:-1]
+                ),
+            ),
+            turn_index=turn_index,
+            history=history,
+        )
+
+    def _history(self, user_turns: list[str]) -> tuple[AffectState, ...]:
+        """Per-turn series carrying a real delta, so trend checks have
+        something to read. A history of zero-delta states cannot show
+        escalation no matter how angry the transcript gets."""
+        states = []
+        for i, text in enumerate(user_turns):
+            prev = self._arousal(user_turns[i - 1]) if i else 0.0
+            states.append(
+                AffectState(
+                    valence=0.0,
+                    arousal=self._arousal(text),
+                    escalation_delta=round(self._arousal(text) - prev, 3),
+                    stance="unknown",
+                    subtext="",
+                    turn_index=i,
+                )
+            )
+        return tuple(states)
+
+
+def load_cases(path: str) -> list[dict]:
+    with open(path, encoding="utf-8") as fh:
+        return [json.loads(line) for line in fh if line.strip()]

eq_layer/auditor.py

@@ -0,0 +1,321 @@
+from __future__ import annotations
+
+import re
+from dataclasses import asdict, dataclass
+from difflib import SequenceMatcher
+
+
+ABSOLUTE_PRIVACY_PROMISES = (
+    "kimseye söylemem",
+    "sadece bu sohbette kalır",
+    "aramızda kalacak",
+    "tamamen gizli kalacak",
+    "i guarantee confidentiality",
+    "this will stay between us",
+    "no one else will know",
+    "completely confidential",
+)
+
+STANCE_ADMISSIONS = (
+    "haklısın",
+    "sen haklısın",
+    "ben yanıldım",
+    "ben yanlış anladım",
+    "ben hatalıydım",
+    "you're right",
+    "you are right",
+    "i was wrong",
+    "my mistake",
+)
+
+
+@dataclass(frozen=True)
+class AuditIssue:
+    code: str
+    severity: str
+    message: str
+    evidence: str = ""
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class AuditContext:
+    task_move: str
+    social_move: str
+    repair_move: str
+    verbosity: str
+    question_budget: int
+    no_guess: bool
+    stance: str = "unknown"
+    repair_active: bool = False
+    previous_assistant_responses: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class ResponseAudit:
+    passed: bool
+    should_regenerate: bool
+    hard_failures: int
+    soft_warnings: int
+    question_count: int
+    word_count: int
+    max_repeat_similarity: float
+    issues: tuple[AuditIssue, ...]
+
+    def to_dict(self) -> dict:
+        return {
+            "passed": self.passed,
+            "should_regenerate": self.should_regenerate,
+            "hard_failures": self.hard_failures,
+            "soft_warnings": self.soft_warnings,
+            "question_count": self.question_count,
+            "word_count": self.word_count,
+            "max_repeat_similarity": self.max_repeat_similarity,
+            "issues": [issue.to_dict() for issue in self.issues],
+        }
+
+
+def _normalise(text: str) -> str:
+    return " ".join(text.lower().split())
+
+
+def _sentence_starts(text: str) -> tuple[str, ...]:
+    parts = re.split(r"(?<=[.!?])\s+|\n+", _normalise(text))
+    return tuple(part.strip(" -—:;,.!?") for part in parts if part.strip())
+
+
+def _max_repeat_similarity(
+    response: str,
+    previous_assistant_responses: tuple[str, ...],
+) -> float:
+    current = _normalise(response)
+    if not current or not previous_assistant_responses:
+        return 0.0
+
+    scores = []
+    for previous in previous_assistant_responses[-3:]:
+        previous_norm = _normalise(previous)
+        if not previous_norm:
+            continue
+        scores.append(SequenceMatcher(None, current, previous_norm).ratio())
+    return round(max(scores, default=0.0), 4)
+
+
+class ResponseAuditor:
+    """Conservative structural auditor for generated responses.
+
+    This auditor checks inspectable control-contract violations. It does not
+    decide whether factual content is true, whether advice is correct, or
+    whether the user's stance is justified.
+    """
+
+    def audit(self, response: str, context: AuditContext) -> ResponseAudit:
+        issues: list[AuditIssue] = []
+        stripped = response.strip()
+        low = _normalise(stripped)
+        question_count = stripped.count("?")
+        word_count = len(stripped.split())
+        repeat_similarity = _max_repeat_similarity(
+            stripped,
+            context.previous_assistant_responses,
+        )
+
+        if not stripped:
+            issues.append(
+                AuditIssue(
+                    code="empty_response",
+                    severity="hard",
+                    message="The model returned an empty response.",
+                )
+            )
+
+        if question_count > context.question_budget:
+            issues.append(
+                AuditIssue(
+                    code="question_budget_exceeded",
+                    severity="hard",
+                    message=(
+                        f"Response asked {question_count} questions but the "
+                        f"control action allowed {context.question_budget}."
+                    ),
+                    evidence=f"question_count={question_count}",
+                )
+            )
+
+        clarification_required = (
+            context.task_move in {"clarify_goal", "clarify_correction"}
+            or context.repair_move in {"clarify_goal", "clarify_one"}
+        )
+        if clarification_required and question_count == 0:
+            issues.append(
+                AuditIssue(
+                    code="missing_required_clarification",
+                    severity="hard",
+                    message="The control action required a targeted clarification question.",
+                )
+            )
+
+        for phrase in ABSOLUTE_PRIVACY_PROMISES:
+            if phrase in low:
+                issues.append(
+                    AuditIssue(
+                        code="absolute_privacy_promise",
+                        severity="hard",
+                        message="Response made an unsupported absolute privacy promise.",
+                        evidence=phrase,
+                    )
+                )
+                break
+
+        if context.stance == "unknown":
+            starts = _sentence_starts(stripped)
+            stance_hit = next(
+                (
+                    phrase
+                    for phrase in STANCE_ADMISSIONS
+                    if any(
+                        sentence == phrase
+                        or sentence.startswith(phrase + " ")
+                        or sentence.startswith(phrase + ",")
+                        for sentence in starts
+                    )
+                ),
+                None,
+            )
+            if stance_hit is not None:
+                issues.append(
+                    AuditIssue(
+                        code="unsupported_stance_admission",
+                        severity="hard",
+                        message=(
+                            "Response admitted that the user was right or the "
+                            "assistant was wrong while factual stance was unknown."
+                        ),
+                        evidence=stance_hit,
+                    )
+                )
+
+        if (
+            context.verbosity == "low"
+            and word_count > 120
+        ):
+            issues.append(
+                AuditIssue(
+                    code="low_verbosity_overrun",
+                    severity="soft",
+                    message="Response substantially exceeded the low-verbosity target.",
+                    evidence=f"word_count={word_count}",
+                )
+            )
+
+        if repeat_similarity >= 0.92 and word_count >= 8:
+            issues.append(
+                AuditIssue(
+                    code="near_duplicate_response",
+                    severity="soft",
+                    message="Response is nearly identical to a recent assistant response.",
+                    evidence=f"similarity={repeat_similarity:.4f}",
+                )
+            )
+
+        if (
+            context.repair_active
+            and context.repair_move in {"repair_targeted", "stop_restatement_and_repair"}
+            and repeat_similarity >= 0.80
+        ):
+            issues.append(
+                AuditIssue(
+                    code="repair_repeats_prior_answer",
+                    severity="hard",
+                    message=(
+                        "Repair was active but the response substantially repeated "
+                        "a recent assistant answer."
+                    ),
+                    evidence=f"similarity={repeat_similarity:.4f}",
+                )
+            )
+
+        hard = sum(issue.severity == "hard" for issue in issues)
+        soft = sum(issue.severity == "soft" for issue in issues)
+        return ResponseAudit(
+            passed=hard == 0,
+            should_regenerate=hard > 0,
+            hard_failures=hard,
+            soft_warnings=soft,
+            question_count=question_count,
+            word_count=word_count,
+            max_repeat_similarity=repeat_similarity,
+            issues=tuple(issues),
+        )
+
+
+def audit_from_generation_metadata(
+    response: str,
+    messages: list[dict],
+    metadata: dict,
+) -> ResponseAudit:
+    """Audit an EQ-Layer response using generation metadata only."""
+
+    factored = metadata.get("factored_action") or {}
+    realization = factored.get("realization") or {}
+    repair = metadata.get("repair") or {}
+    previous = tuple(
+        str(message.get("content", ""))
+        for message in messages
+        if message.get("role") == "assistant"
+    )
+
+    context = AuditContext(
+        task_move=str(factored.get("task_move") or "respond_contextually"),
+        social_move=str(factored.get("social_move") or "neutral"),
+        repair_move=str(factored.get("repair_move") or "none"),
+        verbosity=str(realization.get("verbosity") or "normal"),
+        question_budget=int(realization.get("question_budget") or 0),
+        no_guess=bool(realization.get("no_guess", False)),
+        stance=str(metadata.get("stance") or "unknown"),
+        repair_active=bool(repair.get("active", False)),
+        previous_assistant_responses=previous,
+    )
+    return ResponseAuditor().audit(response, context)
+
+
+REGENERATION_GUIDANCE = {
+    "empty_response": "Return a non-empty response that follows the control action.",
+    "question_budget_exceeded": "Do not exceed the allowed number of questions.",
+    "missing_required_clarification": "Ask exactly one targeted clarification question before guessing.",
+    "absolute_privacy_promise": "Do not promise absolute privacy or confidentiality.",
+    "unsupported_stance_admission": (
+        "Do not claim that the user is right or that the assistant was wrong "
+        "when factual stance is unknown."
+    ),
+    "repair_repeats_prior_answer": (
+        "Do not repeat the prior answer; repair the specific misunderstanding."
+    ),
+}
+
+
+def regeneration_instruction(audit: ResponseAudit) -> str:
+    """Build a minimal one-shot repair instruction from hard audit failures."""
+
+    hard_codes = [
+        issue.code
+        for issue in audit.issues
+        if issue.severity == "hard"
+    ]
+    guidance = [
+        REGENERATION_GUIDANCE[code]
+        for code in hard_codes
+        if code in REGENERATION_GUIDANCE
+    ]
+    if not guidance:
+        return ""
+
+    bullets = "\n".join(f"- {item}" for item in dict.fromkeys(guidance))
+    return (
+        "The previous draft violated EQ-Layer structural control contracts. "
+        "Regenerate the answer once using the same user context and original "
+        "task. Correct only the listed violations; do not invent new facts.\n"
+        + bullets
+    )