Initial commit: Air Agent Framework v2：全双工对话智能体（打断、插话、主动开口）

agent/interruption.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+import time
+from enum import IntEnum
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+class InterruptLevel(IntEnum):
+    LIGHT = 1
+    MEDIUM = 4
+    HIGH = 7
+    URGENT = 10
+
+
+@dataclass
+class InterruptionDecision:
+    should_interrupt: bool = False
+    level: InterruptLevel = InterruptLevel.LIGHT
+    style: str = "light"
+    reason: str = ""
+    suggested_response: str = ""
+
+
+class InterruptionEngine:
+    def __init__(self, llm=None, config=None):
+        self.llm = llm
+        self.config = config
+        self._last_interrupt_time = 0.0
+        self._interrupt_times: list[float] = []
+        self._cooldown = (config.interruption.cooldown_seconds
+                          if config else 3.0)
+        self._max_per_minute = (config.interruption.max_per_minute
+                                if config else 6)
+        self._enabled = (config.interruption.enabled
+                         if config else True)
+
+    async def evaluate(
+        self,
+        input_buffer: str,
+        pause_duration: float,
+        is_sentence_end: bool,
+        context: list[dict] | None = None,
+    ) -> InterruptionDecision:
+        if not self._enabled or not input_buffer.strip():
+            return InterruptionDecision()
+        if not self._can_interrupt():
+            return InterruptionDecision()
+
+        if self.llm:
+            return await self._llm_judge(input_buffer, pause_duration, context)
+        return InterruptionDecision()
+
+    def _can_interrupt(self) -> bool:
+        now = time.time()
+        if now - self._last_interrupt_time < self._cooldown:
+            return False
+        recent = [t for t in self._interrupt_times if now - t < 60]
+        if len(recent) >= self._max_per_minute:
+            return False
+        return True
+
+    def _record_interrupt(self):
+        self._last_interrupt_time = time.time()
+        self._interrupt_times.append(time.time())
+        self._interrupt_times = [
+            t for t in self._interrupt_times if time.time() - t < 60
+        ]
+
+    async def _llm_judge(
+        self, text: str, pause: float, context: list[dict] | None
+    ) -> InterruptionDecision:
+        ctx_preview = ""
+        if context:
+            ctx_preview = "\n".join(
+                f"{m['role']}: {m['content'][-100:]}"
+                for m in context[-4:]
+            )
+
+        prompt = f"""判断是否需要 AI 插话。
+
+用户当前输入（未完成）: "{text}"
+用户停顿: {pause:.1f}秒
+最近对话:
+{ctx_preview}
+
+请输出 JSON:
+{{
+  "should_interrupt": true/false,
+  "priority": "low/medium/high",
+  "style": "light/question/excited/strong",
+  "reason": "简短原因",
+  "suggested_response": "一句话（15字内）"
+}}
+规则：低优先级打断频率 < 2次/分钟。宁可少打断，不要过度打断。"""
+        try:
+            resp = await self.llm.chat(
+                messages=[
+                    {"role": "system", "content": "输出JSON，不要其他内容。"},
+                    {"role": "user", "content": prompt},
+                ],
+                response_format={"type": "json_object"},
+                stream=False,
+            )
+            import json
+            data = json.loads(resp.content)
+            if data.get("should_interrupt"):
+                self._record_interrupt()
+                level_map = {"low": InterruptLevel.LIGHT,
+                             "medium": InterruptLevel.MEDIUM,
+                             "high": InterruptLevel.HIGH}
+                return InterruptionDecision(
+                    should_interrupt=True,
+                    level=level_map.get(data.get("priority", "low"), InterruptLevel.LIGHT),
+                    style=data.get("style", "light"),
+                    reason=data.get("reason", ""),
+                    suggested_response=data.get("suggested_response", ""),
+                )
+        except Exception:
+            pass
+        return InterruptionDecision()