| import os |
| import logging |
|
|
| from fastapi import FastAPI, Depends, HTTPException, Header |
|
|
| from qkernel import QKernel |
| from qkernel.auth import verify_token |
| from qkernel.memory import MemoryEngine |
| from qkernel.policy import PolicyEngine |
| from qkernel.observability import ObservabilityBrain |
| from qkernel.event_bus import EventBus |
| from qkernel.healing import SelfHealingEngine |
| from qkernel.executors import ChatExecutor, MemoryExecutor, ToolExecutor |
| from qkernel.queue import PersistentQueue |
|
|
| logging.basicConfig(level=logging.INFO) |
| logger = logging.getLogger("brain_api") |
|
|
| app = FastAPI(title="Q Brain API") |
|
|
| _queue = PersistentQueue() |
|
|
|
|
| def require_auth(authorization: str | None = Header(None)) -> dict: |
| if not authorization: |
| raise HTTPException(status_code=401, detail="missing_authorization") |
| token = authorization.removeprefix("Bearer ") |
| payload = verify_token(token) |
| if payload is None: |
| raise HTTPException(status_code=401, detail="invalid_or_expired_token") |
| return payload |
|
|
|
|
| def optional_auth(authorization: str | None = Header(None)) -> dict | None: |
| if not authorization: |
| return None |
| token = authorization.removeprefix("Bearer ") |
| return verify_token(token) |
|
|
|
|
| def build_kernel() -> QKernel: |
| kernel = QKernel() |
| from qkernel.policy import PolicyRule |
|
|
| kernel.policy.add_rule(PolicyRule( |
| name="boost_chat", |
| condition=lambda e: e.get("type") == "chat", |
| action=lambda e, ctx: setattr(ctx, "priority_boost", 5) or ctx, |
| )) |
| kernel.policy.add_rule(PolicyRule( |
| name="long_message_route", |
| condition=lambda e: len(e.get("message", "")) > 500, |
| action=lambda e, ctx: setattr(ctx, "route_override", "brain") or ctx, |
| )) |
| kernel.policy.add_rule(PolicyRule( |
| name="route_memory", |
| condition=lambda e: e.get("type") == "memory", |
| action=lambda e, ctx: setattr(ctx, "route_override", "memory") or ctx, |
| )) |
| kernel.policy.add_rule(PolicyRule( |
| name="route_tool", |
| condition=lambda e: e.get("type") == "tool", |
| action=lambda e, ctx: setattr(ctx, "route_override", "tool") or ctx, |
| )) |
| kernel.policy.add_rule(PolicyRule( |
| name="route_voice", |
| condition=lambda e: e.get("type") == "voice", |
| action=lambda e, ctx: setattr(ctx, "route_override", "brain") or ctx, |
| )) |
| chat = ChatExecutor() |
| memory = MemoryExecutor() |
| tool = ToolExecutor() |
| tool.register("echo", lambda p: {"echo": p.get("text", "")}) |
| tool.register("now", lambda p: {"utc_ms": __import__("time").time() * 1000}) |
| kernel.register_service("brain", chat) |
| kernel.register_service("voice", chat) |
| kernel.register_service("network", chat) |
| kernel.register_service("chat", chat) |
| kernel.register_service("memory", memory) |
| kernel.register_service("tool", tool) |
| return kernel |
|
|
|
|
| async def _run_task(event: dict, auth: dict | None): |
| kernel = build_kernel() |
| user_id = (auth or {}).get("user_id", "anonymous") |
| event.setdefault("user_id", user_id) |
| result = await kernel.handle(event) |
| return result |
|
|
|
|
| @app.get("/health") |
| async def health(): |
| return { |
| "status": "ok", |
| "brain": "q-core-v13", |
| "openai": bool(os.getenv("OPENAI_API_KEY", "")), |
| "groq": bool(os.getenv("GROQ_API_KEY", "")), |
| "stripe": bool(os.getenv("STRIPE_SECRET_KEY", "")), |
| "queue": _queue.stats(), |
| } |
|
|
|
|
| @app.post("/brain") |
| async def brain(request: dict, auth: dict | None = Depends(optional_auth)): |
| return await _run_task( |
| { |
| "type": "chat", |
| "message": request.get("message", ""), |
| "context": request.get("context", []), |
| "model": request.get("model", "fast"), |
| }, |
| auth, |
| ) |
|
|
|
|
| @app.post("/v13/task") |
| async def v13_task(request: dict, auth: dict | None = Depends(optional_auth)): |
| task_type = request.get("type", "chat") |
| payload = request.get("payload") or {} |
| mode = request.get("mode", "sync") |
|
|
| if mode != "async": |
| return await _run_task({"type": task_type, **payload}, auth) |
|
|
| task_id = _queue.enqueue(task_type, {"auth_user": (auth or {}).get("user_id"), **payload}) |
| return {"task_id": task_id, "status": "queued", "mode": "async"} |
|
|
|
|
| @app.get("/v13/task/{task_id}") |
| async def v13_task_status(task_id: str, auth: dict | None = Depends(optional_auth)): |
| row = _queue.get(task_id) |
| if row is None: |
| raise HTTPException(status_code=404, detail="task_not_found") |
| return row |
|
|
|
|
| @app.post("/v13/task/process") |
| async def v13_process_queue(auth: dict | None = Depends(optional_auth)): |
| processed = [] |
| while True: |
| task = _queue.dequeue() |
| if task is None: |
| break |
| result = await _run_task( |
| {"type": task["type"], **task["payload"]}, auth |
| ) |
| if result.get("error"): |
| _queue.fail(task["id"], result["error"]) |
| else: |
| _queue.complete(task["id"], result) |
| processed.append({"id": task["id"], "result": result}) |
| return {"processed": processed, "stats": _queue.stats()} |
|
|
|
|
| @app.get("/v13/queue/stats") |
| async def v13_queue_stats(auth: dict | None = Depends(optional_auth)): |
| return _queue.stats() |
|
|
|
|
| @app.post("/event") |
| async def handle_event(event: dict, auth: dict | None = Depends(optional_auth)): |
| return await _run_task(event, auth) |
|
|
|
|
| if __name__ == "__main__": |
| import uvicorn |
|
|
| uvicorn.run(app, host="0.0.0.0", port=8001) |
