| from __future__ import annotations |
|
|
| import json |
| import os |
| import sys |
| from pathlib import Path |
| from typing import Any |
|
|
| import httpx |
| from fastapi import FastAPI |
| from pydantic import BaseModel, Field |
|
|
| ROOT = Path(__file__).resolve().parent |
| sys.path.insert(0, str(ROOT)) |
|
|
| from escalation.patcher import repair |
| from harness.adapters import load |
| from harness.engine import run_harness |
|
|
| CONFIG: dict[str, Any] = json.loads((ROOT / "config.json").read_text(encoding="utf-8")) |
| ADAPTER = load(str(CONFIG.get("adapter") or "generic")) |
| |
| SLM_URL = os.environ.get("MT_SLM_URL", "") |
| ROUTER_URL = os.environ.get("MT_ROUTER_URL", "") |
| TOOLS_URL = os.environ.get("MT_TOOLS_URL", "") |
| RELAY_URL = os.environ.get("MT_RELAY_URL", "") |
| ESCALATION = CONFIG.get("escalation") or {} |
| MODELS: list[str] = list(ESCALATION.get("models") or []) or [str(ESCALATION.get("preferred_model") or "")] |
| TAIL_CHARS = int(ESCALATION.get("session_tail_chars") or 0) |
| MAX_NEW = int((CONFIG.get("slm") or {}).get("max_new_tokens") or 3072) |
|
|
| app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None) |
|
|
|
|
| class HarnessIn(BaseModel): |
| item_id: str |
| task: dict[str, Any] |
| seed: int | None = None |
|
|
|
|
| class RepairIn(BaseModel): |
| item_id: str |
| task: dict[str, Any] |
| draft: Any = None |
| trace: str = "" |
| errors: str = "" |
| ticket: str = "" |
| seed: int | None = None |
|
|
|
|
| class SystemIn(BaseModel): |
| item_id: str |
| task: dict[str, Any] |
| floor: float = Field(ge=0.0, le=1.0) |
| ticket: str = "" |
| seed: int | None = None |
|
|
|
|
| def decide(query: str, draft: str) -> float: |
| if not ROUTER_URL: |
| return 1.0 |
| try: |
| with httpx.Client(timeout=30.0) as http: |
| response = http.post( |
| ROUTER_URL.rstrip("/") + "/decide", json={"input": {"query": query, "draft": draft}} |
| ) |
| response.raise_for_status() |
| answers = response.json().get("answers") or [] |
| return float(answers[0]["probability"]) if answers else 0.0 |
| except Exception: |
| return 0.0 |
|
|
|
|
| def _repair(payload: RepairIn | SystemIn, draft: Any, trace: str, errors: str) -> Any: |
| return repair( |
| payload.task, |
| draft, |
| trace, |
| errors, |
| adapter=ADAPTER, |
| relay_url=RELAY_URL, |
| ticket=payload.ticket, |
| model=MODELS, |
| tail_chars=TAIL_CHARS, |
| max_tokens=MAX_NEW, |
| ) |
|
|
|
|
| def _harness(task: dict[str, Any], seed: int | None): |
| return run_harness( |
| task, adapter=ADAPTER, slm_url=SLM_URL, tools_url=TOOLS_URL, config=CONFIG, seed=seed |
| ) |
|
|
|
|
| @app.get("/health") |
| def health() -> dict[str, str]: |
| return {"status": "ok", "adapter": ADAPTER.name} |
|
|
|
|
| @app.post("/harness/run") |
| def harness_run(payload: HarnessIn) -> dict[str, Any]: |
| result = _harness(payload.task, payload.seed) |
| return { |
| "answer": result.answer, |
| "self_check": {"pass": result.verified}, |
| "trace": result.trace, |
| "steps": result.steps, |
| } |
|
|
|
|
| @app.post("/escalation/repair") |
| def escalation_repair(payload: RepairIn) -> dict[str, Any]: |
| return {"answer": _repair(payload, payload.draft, payload.trace, payload.errors)} |
|
|
|
|
| @app.post("/system/run") |
| def system_run(payload: SystemIn) -> dict[str, Any]: |
| result = _harness(payload.task, payload.seed) |
| draft = result.answer |
| probability = decide(ADAPTER.query(payload.task), ADAPTER.as_text(draft)) |
| if result.verified and probability >= payload.floor: |
| return {"answer": draft, "route": "local", "p": probability} |
| answer = _repair(payload, draft, result.trace, result.errors) |
| return {"answer": answer, "route": "escalated", "p": probability} |
|
|
|
|
| if __name__ == "__main__": |
| import uvicorn |
|
|
| uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("MT_PORT", "8080")), log_level="warning") |
|
|
