from fastapi import FastAPI
from mcp_agent_harness import AgentHarness

app = FastAPI()
harness = AgentHarness("ops-agent")
@harness.tool(max_chars=1000, rate_limit=(10, 60.0), catch_unhandled=True)
def get_status() -> str: return "System healthy"
app.mount("/mcp", harness.sse_app())

flowchart TD
    Client["Autonomous LLM / MCP Client (OpenClaw)"]
    SSE["FastAPI Mount (/mcp/sse)"]
    
    subgraph Harness ["AgentHarness SRE Firewall"]
        Trace["1. Telemetry Tracer (init_trace)"]
        Rate["2. Sliding Window Rate Limiter"]
        Func["3. Tool Execution (Sync/Async)"]
        DFGuard["4. DataFrame Blockade (Zero-Import MRO)"]
        LogGuard["5. Log Line Capping (cap_log_lines)"]
        CtxGuard["6. Context Truncation & XML Strip"]
        ErrWrap["7. Deterministic Error Envelope"]
    end
    
    Backend["Host Backend Services (DB, Redis, APIs)"]

    Client -->|JSON-RPC via SSE| SSE
    SSE --> Trace
    Trace --> Rate
    Rate --> Func
    Func <--> Backend
    Func --> DFGuard
    DFGuard --> LogGuard
    LogGuard --> CtxGuard
    CtxGuard -->|Clean Bounded Payload| Client
    Func -.->|Unhandled Panic / Rate Limit| ErrWrap
    DFGuard -.->|TokenStarvationError| ErrWrap
    ErrWrap -->|JSON Error Envelope| Client

# 1. Build the hardened container image
make build

# 2. Run the integration test suite
make test

# 3. Spin up the harness and verify live endpoint health
make demo

# 4. Run the security, leak, and Trivy CVE audit gate
make audit

from mcp_agent_harness import AgentHarness

harness = AgentHarness(
    name="analytics-mcp",
    instructions="Operational analytics tools for agents.",
    register_builtins=True,
)

@harness.tool(
    max_chars=2000,
    max_lines=200,
    strip_xml=True,
    catch_unhandled=True,
    rate_limit=(10, 60.0),
)
def query_system_logs(service: str) -> str:
    ...

import pandas as pd
from mcp_agent_harness import AgentHarness

harness = AgentHarness()

# ❌ BAD: Leaks raw DataFrame
@harness.tool()
def query_orders() -> pd.DataFrame:
    return pd.DataFrame({"order_id": [1, 2], "amount": [99.5, 14.2]})

# Invoking returns a safe error envelope instead of leaking rows:
# {
#   "status": "error",
#   "error_code": "TokenStarvationError",
#   "message": "Raw DataFrames are strictly prohibited in MCP tools. Return scalar metrics or token-compressed strings.",
#   "trace_id": "mcp-3a1b4c9e"
# }

# ✅ GOOD: Return compact scalar metrics
@harness.tool()
def query_order_metrics() -> dict:
    df = pd.DataFrame({"order_id": [1, 2], "amount": [99.5, 14.2]})
    return {
        "order_count": len(df),
        "total_revenue": float(df["amount"].sum()),
        "average_order": float(df["amount"].mean()),
    }

@harness.tool(rate_limit=(3, 60.0), catch_unhandled=True)
def trigger_external_mutation(action: str) -> dict:
    return {"status": "dispatched", "action": action}

# On the 4th invocation within 60s, execution is stopped before hitting backend:
# {
#   "status": "error",
#   "error_code": "ToolRateLimitError",
#   "message": "Rate limit exceeded: 3 calls per 60.0s limit reached.",
#   "trace_id": "mcp-9b2f11c4"
# }

{
  "status": "error",
  "error_code": "ConnectionResetError",
  "message": "Remote database closed connection",
  "trace_id": "mcp-e4f912a7"
}