monkeybrain-runtime 1.0.0__py3-none-any.whl

src/monkey_brain/api/routes/routes/run.py

@@ -0,0 +1,169 @@
+"""Query route — HTTP interface to the Cognitive Kernel.
+
+This is a thin HTTP adapter. It parses requests, invokes the kernel,
+and formats responses. No execution policy lives here.
+"""
+
+from __future__ import annotations
+
+import json
+import time as _time
+from typing import Any
+
+from fastapi import APIRouter, Depends, Request
+
+from src.monkey_brain.kernel.classifier.embed_classifier import classify_intent
+from src.monkey_brain.kernel.intents.intent_router import execute_intent, unsupported_intent_answer
+from src.monkey_brain.runtime.depedencies import get_runtime
+from src.monkey_brain.runtime.routers import get_mongo_client
+
+import logging
+_rlog = logging.getLogger("agentos.run").info
+
+router = APIRouter()
+
+
+class ProfileEntry:
+    def __init__(self, phase: str, model: str = "", prompt_tokens: int = 0, completion_tokens: int = 0, ms: int = 0):
+        self.phase = phase
+        self.model = model
+        self.prompt_tokens = prompt_tokens
+        self.completion_tokens = completion_tokens
+        self.ms = ms
+
+    def to_dict(self) -> dict:
+        d = {"phase": self.phase, "ms": self.ms}
+        if self.model:
+            d["model"] = self.model
+        if self.prompt_tokens:
+            d["prompt_tokens"] = self.prompt_tokens
+        if self.completion_tokens:
+            d["completion_tokens"] = self.completion_tokens
+        return d
+
+
+_profile_stack: list[list[ProfileEntry]] = []
+
+
+def _profile_start() -> list[ProfileEntry]:
+    entries: list[ProfileEntry] = []
+    _profile_stack.append(entries)
+    return entries
+
+
+def _profile_end() -> list[ProfileEntry]:
+    return _profile_stack.pop() if _profile_stack else []
+
+
+def _profile_add(entry: ProfileEntry):
+    if _profile_stack:
+        _profile_stack[-1].append(entry)
+
+
+async def _llm_call(system: str, user: str, model: str = "") -> str | None:
+    """Call LLM via OpenRouter first, fall back to Ollama."""
+    import os
+    import httpx
+
+    _t0 = _time.monotonic()
+    api_key = os.getenv("OPENROUTER_API_KEY", "")
+    if api_key:
+        try:
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                response = await client.post(
+                    "https://openrouter.ai/api/v1/chat/completions",
+                    headers={
+                        "Authorization": f"Bearer {api_key}",
+                        "Content-Type": "application/json",
+                    },
+                    json={
+                        "model": model or os.getenv("OPENROUTER_MODEL", "openai/gpt-4o-mini"),
+                        "messages": [
+                            {"role": "system", "content": system},
+                            {"role": "user", "content": user},
+                        ],
+                    },
+                )
+                if 200 <= response.status_code < 300:
+                    data = response.json()
+                    return data["choices"][0]["message"]["content"]
+        except Exception:
+            pass
+
+    try:
+        import ollama
+        response = ollama.chat(
+            model="gemma3:latest",
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+        )
+        return response["message"]["content"]
+    except Exception:
+        return None
+
+
+@router.post("/query")
+async def query_agentos(
+    payload: Any,
+    mongo_client=Depends(get_mongo_client),
+):
+    """POST /query — classify intent, execute intent, return answer."""
+    _rlog(f"[query] question={payload.question!r:.100}")
+    _profile_start()
+
+    visible_question = payload.question.split("Graph Details", 1)[0].strip()
+
+    from src.monkey_brain.kernel.nlp.question_analyzer import analyze_question
+    question_analysis = analyze_question(visible_question)
+
+    classified_intent = classify_intent(visible_question, question_analysis)
+    _profile_add(ProfileEntry(
+        phase="Intent Classification",
+        model="embed_classifier",
+        ms=round((_time.monotonic() - _time.monotonic()) * 1000),
+    ))
+
+    if not classified_intent:
+        return {
+            "question": payload.question,
+            "answer": "No intent could be classified for this question.",
+            "semantic_hits": [],
+            "graph_paths": [],
+            "citations": [],
+            "llm_answered": False,
+        }
+
+    result = await execute_intent(
+        mongo_client=mongo_client,
+        question=visible_question,
+        classified_intent=classified_intent,
+    )
+
+    if result is None:
+        return {
+            "question": payload.question,
+            "answer": unsupported_intent_answer(classified_intent),
+            "semantic_hits": [],
+            "graph_paths": [],
+            "citations": [],
+            "llm_answered": False,
+        }
+
+    answer, semantic_hits, graph_paths, llm_answered = result
+
+    pe = _profile_end()
+    return {
+        "question": payload.question,
+        "answer": answer,
+        "semantic_hits": semantic_hits,
+        "graph_paths": graph_paths,
+        "citations": [],
+        "llm_answered": llm_answered,
+        "metadata": {
+            "intent": classified_intent.get("intent"),
+            "confidence": classified_intent.get("confidence"),
+            "profile": [e.to_dict() for e in pe] if pe else [],
+        },
+    }

src/monkey_brain/api/routes/routes/simulate.py

@@ -0,0 +1,485 @@
+"""simulate.py — AgentOS Simulation Route
+
+Takes a prompt and runs it through the world-model simulator to produce
+the predicted (ideal) state, calculate loss against actual query results,
+and store Bellman transition values for the planner.
+
+Loss = 1 - (simulator's predicted entities matching query's actual answer).
+Two independent reads of the same DB, measuring if they agree.
+"""
+
+from __future__ import annotations
+
+import re
+import logging
+from typing import Any
+
+from fastapi import APIRouter, Depends
+from pydantic import BaseModel, Field
+
+from src.monkey_brain.runtime.routers import get_mongo_client
+from src.cortex.world_model_simulation import (
+    ENTITY_TRACKED_COLLECTIONS,
+    _capture_world_state,
+    _store_transition,
+    get_transition_values,
+    simulate,
+)
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+# ---------------------------------------------------------------------------
+# Request / Response models
+# ---------------------------------------------------------------------------
+
+class SimulateRequest(BaseModel):
+    question: str = Field(..., min_length=1, description="Free-text prompt to simulate")
+    context: dict[str, Any] | None = Field(
+        default=None,
+        description="Optional context dict passed through to the simulator",
+    )
+
+
+class SimulateResponse(BaseModel):
+    simulation_id: str
+    question: str
+    predicted_state: dict[str, Any] | None = None
+    state_before: dict[str, Any] | None = None
+    state_delta: dict[str, Any] | None = None
+    impact_assessment: dict[str, Any] | None = None
+    grounding_score: float = 0.0
+    feasibility_verdict: str = "unknown"
+    layers_activated: dict[str, bool] | None = None
+    needs_correction: bool = False
+    correction_prompt: str | None = None
+    loss: dict[str, Any] | None = None
+
+
+class CompareRequest(BaseModel):
+    question: str = Field(..., min_length=1)
+    context: dict[str, Any] | None = None
+
+
+class CompareResponse(BaseModel):
+    question: str
+    predicted: dict[str, Any] | None = None
+    actual: dict[str, Any] | None = None
+    loss: dict[str, Any] | None = None
+    transition_stored: bool = False
+
+
+class TransitionValuesResponse(BaseModel):
+    transitions: list[dict[str, Any]]
+    action_values: dict[str, Any]
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _extract_query_facts(answer: str) -> dict[str, Any]:
+    """Extract factual claims from a query answer string.
+
+    Returns numbers, names, statuses, and collection-like facts found in text.
+    """
+    numbers = set(re.findall(r'\b\d+\.?\d*\b', answer))
+    words = set(re.findall(r'[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*', answer))
+    statuses = set()
+    for s in ("Active", "Operational", "Completed", "In Progress", "Planned",
+              "Released", "Approved", "On Hold", "Cancelled", "Todo",
+              "Under QA Review", "Dispensing", "In Production", "Failed"):
+        if s.lower() in answer.lower():
+            statuses.add(s)
+    return {"numbers": numbers, "names": words, "statuses": statuses}
+
+
+def _compare_predicted_vs_actual(
+    predicted_state: dict[str, Any],
+    query_answer: str,
+    question: str,
+) -> dict[str, Any]:
+    """Compare simulator's entity snapshot against query's actual answer.
+
+    Focuses on RELEVANT collections only — what the question actually asks about.
+    Two independent reads of the same DB, measuring if they agree.
+    """
+    entities = predicted_state.get("entities", {})
+    collections = predicted_state.get("collections", {})
+    query_facts = _extract_query_facts(query_answer)
+    q_lower = question.lower()
+
+    # --- Identify which collections matter for this question ---
+    _KEYWORD_MAP = {
+        "machine": ["pharmaceutical_machines"],
+        "equipment": ["pharmaceutical_equipment"],
+        "instrument": ["pharmaceutical_equipment", "instruments"],
+        "line": ["industrial_lines"],
+        "stage": ["industrial_stages"],
+        "workstation": ["industrial_workstations"],
+        "batch": ["production_batches", "batch_production_execution_records", "batch_step_executions"],
+        "work order": ["work_orders"],
+        "sop": ["sops"],
+        "change control": ["gxp_change_controls"],
+        "oee": ["industrial_lines", "industrial_stages"],
+        "mtbf": ["pharmaceutical_machines"],
+        "plant": ["industrial_plants"],
+        "worker": ["users"],
+        "operator": ["industrial_workstations"],
+        "status": ["pharmaceutical_machines", "industrial_workstations", "industrial_lines"],
+        "capa": ["gxp_change_controls"],
+        "maintenance": ["work_orders"],
+    }
+
+    relevant_cols: set[str] = set()
+    for kw, cols in _KEYWORD_MAP.items():
+        if kw in q_lower:
+            relevant_cols.update(cols)
+
+    # If no keyword matched, fall back to all entity-tracked collections
+    if not relevant_cols:
+        relevant_cols = set(entities.keys()) | set(collections.keys())
+
+    total_facts = 0
+    total_matches = 0
+
+    # --- Detect question type to avoid penalizing irrelevant dimensions ---
+    is_count_question = any(kw in q_lower for kw in ("how many", "count", "number of"))
+    is_name_question = any(kw in q_lower for kw in ("who", "which", "list", "show", "name", "what is", "what are", "what's"))
+    is_status_question = any(kw in q_lower for kw in ("status", "state", "condition"))
+    is_detail_question = any(kw in q_lower for kw in ("detail", "show", "tell me about", "describe"))
+
+    # --- Count matching (always relevant) ---
+    count_matches = 0
+    count_total = 0
+    count_details: list[dict] = []
+    for col in sorted(relevant_cols):
+        info = collections.get(col, {})
+        count = info.get("count", 0)
+        if count > 0:
+            count_total += 1
+            matched = str(count) in query_facts["numbers"]
+            if matched:
+                count_matches += 1
+            count_details.append({"collection": col, "count": count, "found_in_answer": matched})
+
+    total_facts += count_total
+    total_matches += count_matches
+
+    # --- Name matching (skip for pure count questions) ---
+    name_matches = 0
+    name_total = 0
+    name_details: list[dict] = []
+    if not is_count_question:
+        for col in sorted(relevant_cols):
+            info = entities.get(col, {})
+            sim_names = set(info.get("names", []))
+            if not sim_names:
+                continue
+            name_total += len(sim_names)
+            matched_names = [n for n in sim_names if n.lower() in query_answer.lower()]
+            name_matches += len(matched_names)
+            name_details.append({
+                "collection": col,
+                "sim_names": sorted(sim_names),
+                "names_in_answer": sorted(matched_names),
+            })
+        total_facts += name_total
+        total_matches += name_matches
+
+    # --- Status matching (only for status/relevant questions) ---
+    status_matches = 0
+    status_total = 0
+    status_details: list[dict] = []
+    if is_status_question or is_detail_question:
+        for col in sorted(relevant_cols):
+            info = entities.get(col, {})
+            sim_statuses = set(info.get("statuses", {}).keys())
+            if not sim_statuses:
+                continue
+            for s in sim_statuses:
+                status_total += 1
+                if s.lower() in query_answer.lower():
+                    status_matches += 1
+            status_details.append({
+                "collection": col,
+                "sim_statuses": sorted(sim_statuses),
+                "statuses_in_answer": sorted(s for s in sim_statuses if s.lower() in query_answer.lower()),
+            })
+        total_facts += status_total
+        total_matches += status_matches
+    loss = round(1.0 - (total_matches / total_facts), 4) if total_facts else 1.0
+
+    return {
+        "loss": loss,
+        "total_facts": total_facts,
+        "matching_facts": total_matches,
+        "count_accuracy": round(count_matches / count_total, 4) if count_total else 0.0,
+        "name_accuracy": round(name_matches / name_total, 4) if name_total else 0.0,
+        "status_accuracy": round(status_matches / status_total, 4) if status_total else 0.0,
+        "count_matches": count_matches,
+        "name_matches": name_matches,
+        "status_matches": status_matches,
+        "relevant_collections": sorted(relevant_cols),
+        "count_details": count_details,
+        "name_details": name_details,
+        "status_details": status_details,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Endpoints
+# ---------------------------------------------------------------------------
+
+@router.post("/simulate", response_model=SimulateResponse)
+async def run_simulation(
+    payload: SimulateRequest,
+    mongo_client=Depends(get_mongo_client),
+):
+    """Simulate a prompt and return the predicted (ideal) state."""
+    ctx = payload.context or {}
+    if "db" not in ctx and mongo_client is not None:
+        from services.common.config import settings
+        ctx["db"] = mongo_client[settings.DB_NAME]
+
+    result = await simulate(payload.question, context=ctx)
+
+    return SimulateResponse(
+        simulation_id=result.get("simulation_id", ""),
+        question=payload.question,
+        predicted_state=result.get("state_after"),
+        state_before=result.get("state_before"),
+        state_delta=result.get("state_delta"),
+        impact_assessment=result.get("impact_assessment"),
+        grounding_score=result.get("grounding_score", 0.0),
+        feasibility_verdict=result.get("feasibility_verdict", "unknown"),
+        layers_activated=result.get("layers_activated"),
+        needs_correction=result.get("needs_correction", False),
+        correction_prompt=result.get("correction_prompt"),
+        loss=result.get("loss"),
+    )
+
+
+@router.post("/compare", response_model=CompareResponse)
+async def compare_sim_vs_query(
+    payload: CompareRequest,
+    mongo_client=Depends(get_mongo_client),
+):
+    """Compare simulator's predicted state against query's actual answer.
+
+    Flow:
+      1. Capture simulator's entity snapshot (predicted state)
+      2. Run query to get actual answer
+      3. Compare: does the query's answer agree with the simulator's data?
+      4. Store Bellman transition with the computed loss
+    """
+    from services.common.config import settings
+
+    db = None
+    if mongo_client is not None:
+        db = mongo_client[settings.DB_NAME]
+
+    # Step 1: Capture predicted state from simulator
+    ctx = payload.context or {}
+    if "db" not in ctx and db is not None:
+        ctx["db"] = db
+
+    sim_result = await simulate(payload.question, context=ctx)
+    predicted_state = sim_result.get("state_after") or sim_result.get("state_before") or {}
+
+    # Step 2: Run query to get actual answer via HTTP
+    query_answer = ""
+    try:
+        import httpx
+        from services.common.config import settings
+
+        query_url = f"http://localhost:{settings.PORT if hasattr(settings, 'PORT') else 8032}/api/v1/agentos/query"
+        async with httpx.AsyncClient(timeout=180.0) as client:
+            resp = await client.post(query_url, json={
+                "question": payload.question,
+                "top_k": 8,
+                "use_retrieval": False,
+                "use_memory": False,
+                "bypass_cache": True,
+            })
+            if resp.status_code == 200:
+                query_data = resp.json()
+                query_answer = query_data.get("answer", "")
+    except Exception as exc:
+        logger.warning("Compare: query execution failed: %s", exc)
+
+    # Step 3: Compare predicted vs actual
+    loss_result = _compare_predicted_vs_actual(predicted_state, query_answer, payload.question)
+
+    # Step 3.5: Determine pipeline name from question
+    pipeline_name = ""
+    try:
+        from src.monkey_brain.kernel.classifier.embed_classifier import classify_intent
+        from src.monkey_brain.kernel.goal_router import route_question
+        from src.monkey_brain.kernel.nlp.question_analyzer import analyze_question
+        qa = analyze_question(payload.question)
+        ci = classify_intent(payload.question, qa)
+        if ci and ci.get("confidence", 0) >= 0.3:
+            goal = route_question(payload.question, ci)
+            pipeline_name = goal.expert or goal.pipeline_id or ci.get("intent", "")
+            logger.info("[compare] pipeline_name=%r for question=%r", pipeline_name, payload.question[:60])
+    except Exception as exc:
+        logger.warning("[compare] pipeline classification failed: %s", exc)
+
+    # Step 4: Store Bellman transition with correct pipeline_name
+    transition_stored = False
+    if db is not None:
+        try:
+            action = payload.question[:200]
+            await _store_transition(
+                db,
+                simulation_id=sim_result.get("simulation_id", ""),
+                prompt=payload.question,
+                action=action,
+                pipeline_name=pipeline_name,
+                state_before=predicted_state,
+                state_after={"query_answer": query_answer[:2000]},
+                loss_result=loss_result,
+                grounding_score=sim_result.get("grounding_score", 0.0),
+                feasibility_verdict=sim_result.get("feasibility_verdict", "unknown"),
+            )
+            transition_stored = True
+        except Exception as exc:
+            logger.warning("Compare: transition store failed: %s", exc)
+
+    return CompareResponse(
+        question=payload.question,
+        predicted=predicted_state,
+        actual={"query_answer": query_answer[:2000]},
+        loss=loss_result,
+        transition_stored=transition_stored,
+    )
+
+
+@router.get("/transitions", response_model=TransitionValuesResponse)
+async def list_transition_values(
+    action: str | None = None,
+    limit: int = 100,
+    mongo_client=Depends(get_mongo_client),
+):
+    """Retrieve Bellman transition values for the planner."""
+    db = None
+    if mongo_client is not None:
+        from services.common.config import settings
+        db = mongo_client[settings.DB_NAME]
+
+    result = await get_transition_values(db, action=action, limit=limit)
+    return TransitionValuesResponse(**result)
+
+
+# ---------------------------------------------------------------------------
+# Test endpoint — full Bellman cycle verification
+# ---------------------------------------------------------------------------
+
+class BellmanCycleResponse(BaseModel):
+    question: str
+    pipeline_name: str
+    simulate: dict[str, Any]
+    query_answer_preview: str
+    loss: dict[str, Any]
+    transition: dict[str, Any]
+    bellman_values: dict[str, Any]
+
+
+@router.post("/test-bellman-cycle", response_model=BellmanCycleResponse)
+async def test_bellman_cycle(
+    question: str = "How many machines are in the system?",
+    mongo_client=Depends(get_mongo_client),
+):
+    """Run a sample pipeline through the full Bellman cycle and return results.
+
+    Verifies: simulate → query → loss → transition store → transition lookup.
+    """
+    from services.common.config import settings
+
+    db = None
+    if mongo_client is not None:
+        db = mongo_client[settings.DB_NAME]
+
+    # Step 1: Simulate
+    ctx = {"db": db} if db is not None else {}
+    sim_result = await simulate(question, context=ctx)
+
+    # Step 2: Query
+    query_answer = ""
+    try:
+        import httpx
+        async with httpx.AsyncClient(timeout=180.0) as client:
+            resp = await client.post(
+                f"http://localhost:{settings.PORT if hasattr(settings, 'PORT') else 8032}/api/v1/agentos/query",
+                json={"question": question, "top_k": 8, "use_retrieval": False,
+                      "use_memory": False, "bypass_cache": True},
+            )
+            if resp.status_code == 200:
+                query_answer = resp.json().get("answer", "")
+    except Exception:
+        pass
+
+    # Step 3: Loss
+    predicted_state = sim_result.get("state_after") or sim_result.get("state_before") or {}
+    loss_result = _compare_predicted_vs_actual(predicted_state, query_answer, question)
+
+    # Step 4: Store transition
+    pipeline_name = ""
+    try:
+        from src.monkey_brain.kernel.classifier.embed_classifier import classify_intent
+        from src.monkey_brain.kernel.goal_router import route_question
+        from src.monkey_brain.kernel.nlp.question_analyzer import analyze_question
+        qa = analyze_question(question)
+        ci = classify_intent(question, qa)
+        if ci and ci.get("confidence", 0) >= 0.3:
+            goal = route_question(question, ci)
+            pipeline_name = goal.expert or goal.pipeline_id or ci.get("intent", "")
+    except Exception:
+        pass
+
+    transition_stored = False
+    if db is not None:
+        try:
+            await _store_transition(
+                db,
+                simulation_id=sim_result.get("simulation_id", ""),
+                prompt=question,
+                action=question[:200],
+                pipeline_name=pipeline_name,
+                state_before=predicted_state,
+                state_after={"query_answer": query_answer[:2000]},
+                loss_result=loss_result,
+                grounding_score=sim_result.get("grounding_score", 0.0),
+                feasibility_verdict=sim_result.get("feasibility_verdict", "unknown"),
+            )
+            transition_stored = True
+        except Exception:
+            pass
+
+    # Step 5: Lookup transition values
+    bellman_values = {}
+    if db is not None:
+        try:
+            tv = await get_transition_values(db, pipeline_name=pipeline_name, limit=10)
+            bellman_values = tv.get("action_values", {})
+        except Exception:
+            pass
+
+    return BellmanCycleResponse(
+        question=question,
+        pipeline_name=pipeline_name,
+        simulate={
+            "simulation_id": sim_result.get("simulation_id"),
+            "grounding_score": sim_result.get("grounding_score"),
+            "feasibility_verdict": sim_result.get("feasibility_verdict"),
+            "layers_activated": sim_result.get("layers_activated"),
+            "entity_count": len(predicted_state.get("entities", {})),
+        },
+        query_answer_preview=query_answer[:500],
+        loss=loss_result,
+        transition={"stored": transition_stored, "pipeline_name": pipeline_name},
+        bellman_values=bellman_values,
+    )

src/monkey_brain/dlm/__init__.py

@@ -0,0 +1,44 @@
+"""DLM — Data Lifecycle Manager for AgentOS.
+
+Manages the lifecycle of all runtime data.
+Ensures AgentOS remains performant and storage-efficient.
+
+Provides:
+- TTL Management
+- Garbage Collection
+- Storage Monitoring
+- Orphan Detection
+- Lifecycle Policies
+"""
+
+from src.monkey_brain.dlm.dlm import Dlm
+from src.monkey_brain.dlm.lifecycle import (
+    LifecyclePolicy,
+    StorageClass,
+    ExpirationAction,
+    get_policy,
+    DATA_POLICIES,
+)
+from src.monkey_brain.dlm.ttl import TtlManager, TtlEntry
+from src.monkey_brain.dlm.gc import GarbageCollector, CollectionResult
+from src.monkey_brain.dlm.storage import StorageMonitor, StorageQuota, StorageSnapshot
+from src.monkey_brain.dlm.orphans import OrphanDetector, Orphan, OrphanScanResult
+
+__all__ = [
+    "Dlm",
+    "LifecyclePolicy",
+    "StorageClass",
+    "ExpirationAction",
+    "get_policy",
+    "DATA_POLICIES",
+    "TtlManager",
+    "TtlEntry",
+    "GarbageCollector",
+    "CollectionResult",
+    "StorageMonitor",
+    "StorageQuota",
+    "StorageSnapshot",
+    "OrphanDetector",
+    "Orphan",
+    "OrphanScanResult",
+]