open-reflection-protocol 0.3.0__py3-none-any.whl

orp/effects.py

@@ -0,0 +1,112 @@
+"""Effect Evaluator — 分级效果评估
+
+评估方法分级:
+1. descriptive: 仅记录检索/应用/结果，不声称因果
+2. matched_baseline: 匹配相似任务/Agent/模型版本的基线
+3. randomized: A/B 实验
+4. causal_model: 贝叶斯分层等因果方法
+"""
+
+from typing import Any, Optional
+
+from orp.schema import (
+    Lesson, LessonEvaluation, EvaluationMethod, LessonStatus,
+)
+from orp.storage import ORPStorage
+
+
+class EffectEvaluator:
+    """Lesson 效果评估"""
+
+    def __init__(self, storage: Optional[ORPStorage] = None):
+        self._storage = storage or ORPStorage()
+
+    def describe(self, lesson: Lesson) -> LessonEvaluation:
+        """Descriptive 评估 — 仅记录统计"""
+        m = lesson.metrics
+        return LessonEvaluation(
+            lesson_id=lesson.lesson_id,
+            method=EvaluationMethod.DESCRIPTIVE,
+            population={"agent_version": lesson.scope.get("agent_versions", [])},
+            results={
+                "with_lesson": {
+                    "tasks": m.get("retrieved", 0),
+                    "successes": m.get("successful_after_apply", 0),
+                },
+                "baseline": {"tasks": 0, "successes": 0},
+                "estimated_effect": None,
+                "uncertainty_interval": None,
+            },
+            decision="keep_active",
+        )
+
+    def evaluate_matched_baseline(self, lesson: Lesson,
+                                  baseline_success_rate: float = 0.5,
+                                  baseline_tasks: int = 1) -> LessonEvaluation:
+        """Matched Baseline 评估 — 与基线比较"""
+        m = lesson.metrics
+        applied = m.get("applied", 0)
+        successes = m.get("successful_after_apply", 0)
+        
+        with_rate = successes / applied if applied > 0 else 0
+        raw_effect = with_rate - baseline_success_rate
+        
+        return LessonEvaluation(
+            lesson_id=lesson.lesson_id,
+            method=EvaluationMethod.MATCHED_BASELINE,
+            population={
+                "agent_version": lesson.scope.get("agent_versions", []),
+                "baseline_source": "matched_tasks",
+            },
+            results={
+                "with_lesson": {
+                    "tasks": applied,
+                    "successes": successes,
+                    "success_rate": round(with_rate, 3),
+                },
+                "baseline": {
+                    "tasks": baseline_tasks,
+                    "successes": int(baseline_tasks * baseline_success_rate),
+                    "success_rate": round(baseline_success_rate, 3),
+                },
+                "estimated_effect": round(raw_effect, 3) if applied > 0 else None,
+                "uncertainty_interval": None,
+            },
+            decision=self._decide(raw_effect, applied),
+        )
+
+    def _decide(self, effect: float, sample: int) -> str:
+        """基于效果和样本量生成处置建议"""
+        if sample < 3:
+            return "keep_active"  # 样本太少，不做决定
+        if effect > 0.1:
+            return "keep_active"
+        if effect < -0.1:
+            return "review"
+        if effect < -0.3:
+            return "deprecate"
+        return "keep_active"
+
+    def auto_evaluate_all(self) -> list[LessonEvaluation]:
+        """对所有 active Lesson 运行 matched_baseline 评估"""
+        evaluations = []
+        for lesson in self._storage.list_lessons(status=LessonStatus.ACTIVE):
+            evals_list = self._storage.conn.execute(
+                "SELECT * FROM lesson_evals WHERE lesson_id = ? ORDER BY created_at DESC LIMIT 5",
+                (lesson.lesson_id,)
+            ).fetchall()
+            baseline_rate = 0.5
+            if evals_list:
+                # 尝试从上次评估获取基线
+                for r in evals_list:
+                    import json
+                    results = json.loads(r["results_json"]) if r["results_json"] else {}
+                    baseline = results.get("baseline", {})
+                    if baseline.get("success_rate"):
+                        baseline_rate = baseline["success_rate"]
+                        break
+            
+            evaluation = self.evaluate_matched_baseline(lesson, baseline_rate)
+            self._storage.save_lesson_evaluation(evaluation)
+            evaluations.append(evaluation)
+        return evaluations

orp/evidence.py

@@ -0,0 +1,92 @@
+"""证据管理 — 哈希、引用、可信等级、脱敏"""
+
+import hashlib
+import json
+import re
+from pathlib import Path
+from typing import Any, Optional
+
+from orp.schema import TrustLevel, EvidenceRef
+
+
+DEFAULT_REDACTION_PATTERNS: list[tuple[str, str]] = [
+    (r'(api[_-]?key|apikey|token|secret|password|passwd|credential)\s*[:=]\s*["\']?[^"\'&\s]+', r'***REDACTED***'),
+    (r'(?:(?:sk|pk|ghp|gho|ghu|ghs|ghr)_[a-zA-Z0-9]{10,})', '***REDACTED***'),
+    (r'(?:(?:AKIA|ASIA)[0-9A-Z]{16})', '***REDACTED***'),
+    (r'(?:\d{4}[-]?\d{4}[-]?\d{4}[-]?\d{4})', '***REDACTED***'),
+    (r'(?:eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,})', '***JWT-REDACTED***'),
+]
+
+
+def compute_hash(content: str) -> str:
+    return f"sha256:{hashlib.sha256(content.encode()).hexdigest()}"
+
+
+def compute_file_hash(path: str) -> Optional[str]:
+    try:
+        content = Path(path).read_text()
+        return compute_hash(content)
+    except (FileNotFoundError, IOError):
+        return None
+
+
+def redact_text(text: str, patterns: Optional[list[tuple[str, str]]] = None) -> str:
+    """对文本应用脱敏模式"""
+    if patterns is None:
+        patterns = DEFAULT_REDACTION_PATTERNS
+    result = text
+    for pattern, replacement in patterns:
+        result = re.sub(pattern, replacement, result, flags=re.IGNORECASE)
+    return result
+
+
+def redact_sensitive_fields(data: dict[str, Any], depth: int = 0) -> dict[str, Any]:
+    """递归脱敏字典中的敏感字段"""
+    SENSITIVE_KEYS = {"api_key", "apiKey", "apikey", "token", "secret", "password", "credential", "private_key"}
+    if depth > 10:
+        return data
+    result = {}
+    for k, v in data.items():
+        if any(sk in k.lower() for sk in SENSITIVE_KEYS):
+            result[k] = "***REDACTED***"
+        elif isinstance(v, dict):
+            result[k] = redact_sensitive_fields(v, depth + 1)
+        elif isinstance(v, str):
+            result[k] = redact_text(v)
+        else:
+            result[k] = v
+    return result
+
+
+def make_evidence_ref(uri: str, content: Optional[str] = None) -> EvidenceRef:
+    """创建证据引用，可选带内容哈希"""
+    ref = EvidenceRef(
+        evidence_id=f"ref_{hashlib.md5(uri.encode()).hexdigest()[:12]}",
+        kind="tool_output",
+        uri=uri,
+    )
+    if content:
+        ref.digest = compute_hash(content)
+    return ref
+
+
+def infer_trust_level(evidence_refs: list[str], source: str) -> TrustLevel:
+    """根据证据引用和来源推断可信等级"""
+    if not evidence_refs:
+        return TrustLevel.ASSERTED
+    if source == "human":
+        return TrustLevel.HUMAN_CONFIRMED
+    if source == "tool" or source == "system":
+        return TrustLevel.OBSERVED
+    return TrustLevel.ASSERTED
+
+
+def canonicalize_evidence_id(raw: str) -> str:
+    """规范化证据 ID 格式"""
+    raw = raw.strip()
+    if raw.startswith("artifact:") or raw.startswith("file:") or raw.startswith("eval:"):
+        return raw
+    if raw.startswith("sha256:") or raw.startswith("ref_"):
+        return raw
+    # default to artifact prefix
+    return f"artifact:{raw}"

orp/examples/failing_coding_agent.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""Example failing coding agent — simulates a buggy agent for ORP testing"""
+
+import sys
+
+
+def fix_authentication():
+    """Simulates fixing an auth bug — but misses the anonymous user path"""
+    # This "fix" only covers logged-in users
+    print("Fixing authentication controller...")
+    print("Added null check for authenticated user")
+    print("Running tests...")
+    print("pytest: 34 passed, 1 failed")
+    print("FAILED tests/test_anonymous_access.py::test_anonymous_user_get_name")
+    sys.exit(1)
+
+
+def fix_with_tests_first():
+    """Alternative strategy: write tests first, then fix"""
+    print("Step 1: Writing anonymous user regression test...")
+    print("tests/test_anonymous_access.py written")
+    print("Step 2: Running test to confirm failure...")
+    print("FAILED as expected — test reproduces the bug")
+    print("Step 3: Fixing the implementation...")
+    print("Added null check for anonymous user")
+    print("Step 4: Running all tests...")
+    print("pytest: 35 passed, 0 failed")
+    print("All tests pass!")
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    # By default, simulate the failing path
+    mode = sys.argv[1] if len(sys.argv) > 1 else "failing"
+    if mode == "failing":
+        fix_authentication()
+    else:
+        fix_with_tests_first()

orp/experience.py

@@ -0,0 +1,114 @@
+"""Experience Builder — 从异构 trace 构建 ExperienceRecord"""
+
+import json
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+from orp.schema import (
+    ExperienceRecord, TimelineEvent, EventKind, Outcome, ReflectionAnalysis,
+)
+from orp.evidence import redact_text, redact_sensitive_fields, make_evidence_ref
+
+
+class ExperienceBuilder:
+    """将异构 trace 统一为 ExperienceRecord"""
+
+    def from_trace(self, trace: dict[str, Any],
+                   agent_id: str = "unknown",
+                   goal: str = "") -> ExperienceRecord:
+        """从通用 trace dict 构建 ExperienceRecord"""
+        timeline = self._extract_timeline(trace)
+        outcome = self._extract_outcome(trace)
+        reflection = self._extract_reflection(trace)
+        
+        return ExperienceRecord(
+            agent={"id": agent_id, "version": trace.get("agent_version", ""),
+                   "model": trace.get("model", "")},
+            task={"goal": goal or trace.get("goal", ""),
+                  "domain": trace.get("domain", ""),
+                  "input_ref": trace.get("input_ref", "")},
+            trace_ref=trace.get("trace_id") or trace.get("trace_ref"),
+            timeline=timeline,
+            outcome=outcome,
+            reflection=reflection,
+        )
+
+    def from_events(self, events: list[TimelineEvent],
+                    goal: str = "",
+                    agent_id: str = "unknown") -> ExperienceRecord:
+        """直接从 TimelineEvent 列表构建"""
+        outcome = Outcome()
+        # 检查是否有 outcome event
+        for evt in events:
+            if evt.kind == EventKind.OUTCOME:
+                outcome.status = evt.content
+                break
+        return ExperienceRecord(
+            agent={"id": agent_id},
+            task={"goal": goal},
+            timeline=events,
+            outcome=outcome,
+        )
+
+    def _extract_timeline(self, trace: dict[str, Any]) -> list[TimelineEvent]:
+        """从 trace dict 提取时间线事件"""
+        events: list[TimelineEvent] = []
+        raw_events = trace.get("events") or trace.get("spans") or trace.get("steps", [])
+        for i, raw in enumerate(raw_events):
+            events.append(TimelineEvent(
+                kind=raw.get("kind", raw.get("type", "observation")),
+                source=raw.get("source", "agent"),
+                content=raw.get("content", raw.get("message", str(raw))),
+                evidence_refs=raw.get("evidence_refs", []),
+            ))
+        if not events:
+            events.append(TimelineEvent(
+                kind="observation",
+                content=f"Trace captured {len(raw_events)} unknown events"
+            ))
+        return events
+
+    def _extract_outcome(self, trace: dict[str, Any]) -> Outcome:
+        raw = trace.get("outcome", {})
+        if isinstance(raw, str):
+            return Outcome(status=raw)
+        return Outcome(**raw)
+
+    def _extract_reflection(self, trace: dict[str, Any]) -> Optional[ReflectionAnalysis]:
+        raw = trace.get("reflection")
+        if not raw:
+            return None
+        if isinstance(raw, ReflectionAnalysis):
+            return raw
+        return ReflectionAnalysis(**raw)
+
+
+class Redactor:
+    """对 ExperienceRecord 应用脱敏"""
+
+    @staticmethod
+    def apply(record: ExperienceRecord) -> ExperienceRecord:
+        record.task["goal"] = redact_text(record.task.get("goal", ""))
+        for evt in record.timeline:
+            evt.content = redact_text(evt.content)
+            evt.evidence_refs = [
+                r if r.startswith(("artifact:", "eval:")) else f"ref:{hash(r)}"
+                for r in evt.evidence_refs
+            ]
+        return record
+
+
+class EvidenceLinker:
+    """链接与验证证据引用"""
+
+    @staticmethod
+    def link(record: ExperienceRecord) -> ExperienceRecord:
+        for evt in record.timeline:
+            seen = set()
+            linked = []
+            for ref in evt.evidence_refs:
+                if ref not in seen:
+                    seen.add(ref)
+                    linked.append(ref)
+            evt.evidence_refs = linked
+        return record

orp/export.py

@@ -0,0 +1,60 @@
+"""Export Engine — ORP JSON / OTLP refs / eval files"""
+
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+from orp.schema import ExperienceRecord
+from orp.storage import ORPStorage
+
+
+class ExportEngine:
+    """导出到多种格式"""
+
+    def __init__(self, storage: Optional[ORPStorage] = None):
+        self._storage = storage or ORPStorage()
+
+    def to_json(self, experience_id: str) -> Optional[str]:
+        """导出为 JSON"""
+        if experience_id == "latest":
+            exps = self._storage.list_experiences(limit=1)
+            if not exps:
+                return None
+            exp = exps[0]
+        else:
+            exp = self._storage.get_experience(experience_id)
+        if not exp:
+            return None
+        return json.dumps(exp.model_dump(), indent=2, default=str)
+
+    def to_json_file(self, experience_id: str, path: str) -> bool:
+        content = self.to_json(experience_id)
+        if not content:
+            return False
+        Path(path).write_text(content)
+        return True
+
+    def to_otlp_refs(self, experience_id: str) -> dict[str, Any]:
+        if experience_id == "latest":
+            exps = self._storage.list_experiences(limit=1)
+            if not exps:
+                return {}
+            exp = exps[0]
+        else:
+            exp = self._storage.get_experience(experience_id)
+        if not exp:
+            return {}
+        return {
+            "resource": {"orp": {"version": "0.3"}},
+            "scopeSpans": [{
+                "scope": {"name": "orp.experience"},
+                "spans": [{
+                    "spanId": exp.experience_id[:16],
+                    "name": exp.task.get("goal", "")[:50],
+                    "attributes": {
+                        "orp.experience.id": exp.experience_id,
+                        "orp.schema.version": "0.3",
+                    },
+                }],
+            }],
+        }

orp/lessons.py

@@ -0,0 +1,95 @@
+"""Lesson Store — 检索、冲突检测、过期处理"""
+
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+from orp.schema import Lesson, LessonStatus, check_lesson_conflict
+from orp.storage import ORPStorage
+
+
+class LessonStore:
+    """Lesson 存储与检索"""
+
+    def __init__(self, storage: Optional[ORPStorage] = None):
+        self._storage = storage or ORPStorage()
+
+    def retrieve(self, task: str, limit: int = 3,
+                 status: LessonStatus = LessonStatus.ACTIVE,
+                 domain: Optional[str] = None) -> list[Lesson]:
+        """检索与当前任务相关 Lesson
+        
+        排序信号: 语义相关性 → 验证等级 → 历史有效性
+        """
+        candidates = self._storage.list_lessons(status=status, limit=50)
+        
+        # 过滤过期
+        now = datetime.now(timezone.utc)
+        candidates = [l for l in candidates if not l.expires_at or l.expires_at > now]
+        
+        # 按相关性评分排序
+        scored = []
+        task_lower = task.lower()
+        for lesson in candidates:
+            score = self._relevance_score(lesson, task_lower, domain)
+            if score > 0:
+                scored.append((score, lesson))
+        
+        scored.sort(key=lambda x: -x[0])
+        return [lesson for _, lesson in scored[:limit]]
+
+    def _relevance_score(self, lesson: Lesson, task: str, domain: Optional[str] = None) -> float:
+        """计算 Lesson 与任务的语义相关性分数"""
+        score = 0.0
+        # 领域匹配
+        if domain and domain in lesson.scope.get("task_domains", []):
+            score += 3.0
+        
+        # 条件匹配
+        for condition in lesson.trigger.get("conditions", []):
+            if any(word in task for word in condition.lower().split()):
+                score += 2.0
+            if condition.lower() in task:
+                score += 4.0
+        
+        # 验证等级加权
+        validation_level = lesson.validation.get("level", "asserted")
+        level_bonus = {
+            "asserted": 0.5, "observed": 1.0, "reproduced": 1.5,
+            "externally_verified": 2.0, "human_confirmed": 2.5,
+            "regression_guarded": 3.0,
+        }
+        score += level_bonus.get(validation_level, 0.5)
+        
+        # 历史效果
+        effect = lesson.metrics.get("estimated_effect")
+        if effect is not None and effect > 0:
+            score += min(effect * 2, 2.0)
+        
+        return score
+
+    def check_expired(self) -> list[Lesson]:
+        """找出所有过期的 Lesson 并自动 deprecated"""
+        now = datetime.now(timezone.utc)
+        expired = []
+        for lesson in self._storage.list_lessons(status=LessonStatus.ACTIVE):
+            if lesson.expires_at and lesson.expires_at < now:
+                self._storage.update_lesson_status(
+                    lesson.lesson_id, LessonStatus.DEPRECATED
+                )
+                lesson.status = LessonStatus.DEPRECATED
+                expired.append(lesson)
+        return expired
+
+    def validate_lesson(self, lesson_id: str) -> list[str]:
+        """验证一条 Lesson 的完整性"""
+        lesson = self._storage.get_lesson(lesson_id)
+        if not lesson:
+            return ["Lesson not found"]
+        issues = []
+        if not lesson.recommendation:
+            issues.append("Missing recommendation")
+        if not lesson.trigger.get("conditions"):
+            issues.append("Missing trigger conditions")
+        if not lesson.scope.get("task_domains"):
+            issues.append("Missing task_domains in scope")
+        return issues

orp/mcp_server.py

@@ -0,0 +1,171 @@
+"""MCP Lesson Server — 通过 MCP 协议让 Agent 查询和回报 Lesson
+
+提供工具:
+- orp_retrieve_lessons(task, limit, scope)
+- orp_acknowledge_lesson(lesson_id)
+- orp_report_outcome(lesson_id, outcome, evidence_refs)
+"""
+
+import json
+import sys
+from typing import Any, Optional
+
+from orp.schema import LessonStatus, DeliveryStrategy
+from orp.storage import ORPStorage
+from orp.lessons import LessonStore
+from orp.delivery import DeliveryRouter
+
+
+class MCPServer:
+    """MCP Lesson Server — 通过 stdio 或 HTTP 提供 MCP 工具"""
+
+    def __init__(self, storage: Optional[ORPStorage] = None,
+                 transport: str = "stdio"):
+        self.transport = transport
+        self._store = LessonStore(storage)
+        self._router = DeliveryRouter(storage)
+
+    def get_tool_definitions(self) -> list[dict[str, Any]]:
+        """返回 MCP 工具定义（符合 MCP 规范）"""
+        return [
+            {
+                "name": "orp_retrieve_lessons",
+                "description": "Retrieve relevant lessons for a task. Call at the START of a task to learn from past experiences.",
+                "parameters": {
+                    "type": "object",
+                    "required": ["task"],
+                    "properties": {
+                        "task": {"type": "string", "description": "The task description to find relevant lessons for"},
+                        "limit": {"type": "integer", "description": "Max lessons to return", "default": 3},
+                        "domain": {"type": "string", "description": "Optional domain filter (e.g. coding, research)"},
+                    },
+                },
+            },
+            {
+                "name": "orp_acknowledge_lesson",
+                "description": "Confirm that a lesson has been received and understood. Call after receiving a lesson.",
+                "parameters": {
+                    "type": "object",
+                    "required": ["lesson_id"],
+                    "properties": {
+                        "lesson_id": {"type": "string", "description": "The lesson ID to acknowledge"},
+                    },
+                },
+            },
+            {
+                "name": "orp_report_outcome",
+                "description": "Report whether applying a lesson improved the outcome. Call at the END of a task.",
+                "parameters": {
+                    "type": "object",
+                    "required": ["lesson_id", "outcome"],
+                    "properties": {
+                        "lesson_id": {"type": "string", "description": "The lesson ID that was applied"},
+                        "outcome": {"type": "string", "enum": ["success", "failed", "improved", "worse"],
+                                    "description": "Did the lesson help?"},
+                        "evidence_refs": {
+                            "type": "array", "items": {"type": "string"},
+                            "description": "Optional evidence references (test results, git diff, etc.)",
+                        },
+                    },
+                },
+            },
+        ]
+
+    def handle_call(self, tool_name: str, arguments: dict[str, Any]) -> dict[str, Any]:
+        """处理 MCP 工具调用"""
+        if tool_name == "orp_retrieve_lessons":
+            task = arguments.get("task", "")
+            limit = arguments.get("limit", 3)
+            domain = arguments.get("domain")
+            lessons = self._store.retrieve(
+                task=task, limit=limit,
+                domain=domain,
+            )
+            return {
+                "lessons": [
+                    {
+                        "lesson_id": l.lesson_id,
+                        "recommendation": l.recommendation,
+                        "status": l.status.value,
+                        "validation_level": l.validation.get("level", "asserted"),
+                        "scope": l.scope,
+                    }
+                    for l in lessons
+                ],
+                "count": len(lessons),
+            }
+
+        elif tool_name == "orp_acknowledge_lesson":
+            lesson_id = arguments.get("lesson_id", "")
+            lesson = self._store._storage.get_lesson(lesson_id)
+            if lesson:
+                lesson.metrics["acknowledged"] = lesson.metrics.get("acknowledged", 0) + 1
+                self._store._storage.save_lesson(lesson)
+                return {"status": "acknowledged", "lesson_id": lesson_id}
+            return {"status": "error", "message": "Lesson not found"}
+
+        elif tool_name == "orp_report_outcome":
+            lesson_id = arguments.get("lesson_id", "")
+            outcome = arguments.get("outcome", "")
+            evidence_refs = arguments.get("evidence_refs", [])
+            self._router.report_outcome(lesson_id, outcome, evidence_refs)
+            return {"status": "recorded", "lesson_id": lesson_id, "outcome": outcome}
+
+        return {"status": "error", "message": f"Unknown tool: {tool_name}"}
+
+    def run_stdio(self) -> None:
+        """通过 stdio 运行 MCP Server（符合 MCP 协议）"""
+        # MCP 初始化
+        init_msg = json.dumps({
+            "jsonrpc": "2.0",
+            "method": "initialize",
+            "params": {
+                "protocolVersion": "0.1.0",
+                "capabilities": {
+                    "tools": {},
+                },
+                "clientInfo": {"name": "orp-mcp-server", "version": "0.3.0"},
+            },
+        })
+        sys.stdout.write(f"Content-Length: {len(init_msg)}\r\n\r\n{init_msg}")
+        sys.stdout.flush()
+
+        # 发送工具列表
+        tool_msg = json.dumps({
+            "jsonrpc": "2.0",
+            "method": "notifications/tools/list_changed",
+            "params": {"tools": self.get_tool_definitions()},
+        })
+        sys.stdout.write(f"Content-Length: {len(tool_msg)}\r\n\r\n{tool_msg}")
+        sys.stdout.flush()
+
+        # 主循环
+        buffer = ""
+        while True:
+            try:
+                line = sys.stdin.readline()
+                if not line:
+                    break
+                buffer += line
+                if "\r\n\r\n" in buffer:
+                    parts = buffer.split("\r\n\r\n", 1)
+                    body = parts[1]
+                    buffer = ""
+                    try:
+                        request = json.loads(body)
+                        if request.get("method") == "tools/call":
+                            result = self.handle_call(
+                                request["params"]["name"],
+                                request["params"].get("arguments", {}),
+                            )
+                            response = json.dumps({
+                                "jsonrpc": "2.0",
+                                "id": request.get("id"),
+                                "result": result,
+                            })
+                            sys.stdout.write(f"Content-Length: {len(response)}\r\n\r\n{response}")
+                            sys.stdout.flush()
+                    except json.JSONDecodeError:
+                        pass
+            except (EOFError, KeyboardInterrupt):
+                break