TealMonitor v2

pip install tealtiger

import asyncio
from tealtiger.monitor import TealMonitor

monitor = TealMonitor(
    limits={
        "per_request": 2.00,
        "daily_per_agent": 50.00,
        "daily_global": 500.00,
        "monthly": 10000.00,
    },
    reasoning_budget={
        "enabled": True,
        "max_per_request": 10000,
        "daily_limit": 100000,
    },
    anomaly_detection={
        "enabled": True,
        "sensitivity": "medium",
        "baseline_window": "7d",
        "on_anomaly": "approval_required",
    },
    attribution={"enabled": True, "group_by": "team"},
    cost_model={
        "pricing": {
            "gpt-4o": {"input_per_1m": 2.50, "output_per_1m": 10.00},
            "o1": {"input_per_1m": 15.00, "output_per_1m": 60.00, "reasoning_per_1m": 60.00},
            "claude-3.5-sonnet": {"input_per_1m": 3.00, "output_per_1m": 15.00},
        },
        "include_reasoning_tokens": True,
    },
)

async def main():
    decision = await monitor.evaluate(
        request={
            "model": "o1",
            "estimated_input_tokens": 2000,
            "estimated_output_tokens": 500,
            "estimated_reasoning_tokens": 8000,
        },
        ctx={
            "agent_id": "research-bot-001",
            "correlation_id": "req-001",
            "session_id": "sess-abc",
        },
    )

    print(f"Allowed: {decision.allowed}")
    print(f"Estimated cost: ${decision.estimated_cost:.2f}")
    print(f"Daily remaining: ${decision.budget_remaining['daily']:.2f}")
    print(f"Anomaly score: {decision.anomaly_score:.2f}")

asyncio.run(main())

class TealMonitor:
    def __init__(
        self,
        limits: dict,
        reasoning_budget: dict | None = None,
        anomaly_detection: dict | None = None,
        attribution: dict | None = None,
        cost_model: dict | None = None,
    ) -> None: ...

    async def evaluate(self, request: dict, ctx: dict) -> CostDecision: ...

    async def get_spend(self, agent_id: str, window: str = "24h") -> SpendReport: ...

    async def get_anomaly_status(self, agent_id: str) -> AnomalyStatus: ...

    async def record_cost(self, correlation_id: str, actual_cost: dict) -> None: ...

monitor = TealMonitor(
    limits={
        "per_request": 2.00,       # Max USD per request
        "per_session": 20.00,      # Max USD per session
        "daily_per_agent": 50.00,  # Max USD per agent per day
        "daily_global": 500.00,    # Max USD across all agents per day
        "monthly": 10000.00,       # Monthly budget cap
    },
)

decision = await monitor.evaluate(
    request={
        "model": "o1",
        "estimated_input_tokens": 1000,
        "estimated_output_tokens": 200,
        "estimated_reasoning_tokens": 15000,  # Exceeds 10000 budget
    },
    ctx={"agent_id": "agent-001", "correlation_id": "req-001"},
)

# decision.allowed == False
# decision.reason_codes == ["REASONING_TOKEN_BUDGET_EXCEEDED"]
# decision.reasoning_tokens_used == 15000
# decision.reasoning_tokens_budget == 10000

anomaly = await monitor.get_anomaly_status("research-bot-001")

print(f"Score: {anomaly.score:.2f}")     # 0.75 (elevated)
print(f"Flagged: {anomaly.flagged}")     # True
print(f"Baseline daily avg: ${anomaly.baseline['daily_avg']:.2f}")
print(f"Today's spend: ${anomaly.current['today_spend']:.2f}")

for dev in anomaly.deviations:
    print(f"  {dev['dimension']}: z={dev['z_score']:.1f} — {dev['explanation']}")

# Agent-level spend report
report = await monitor.get_spend("research-bot-001", window="7d")

print(f"Total cost: ${report.total_cost:.2f}")
print(f"By model: {report.by_model}")       # {"gpt-4o": 45.00, "o1": 42.50}
print(f"Requests: {report.request_count}")   # 342
print(f"Avg cost/request: ${report.avg_cost_per_request:.3f}")

# Team-level aggregation
team_report = await monitor.get_spend("team:ml-research", window="30d")
print(f"Team total: ${team_report.total_cost:.2f}")

await monitor.record_cost(
    correlation_id="req-001",
    actual_cost={
        "model": "o1",
        "input_tokens": 1850,
        "output_tokens": 420,
        "reasoning_tokens": 7200,
        "actual_cost": 0.48,
        "duration_ms": 3200,
    },
)

from dataclasses import dataclass

@dataclass
class CostDecision:
    allowed: bool
    estimated_cost: float              # Estimated USD for this request
    reason_codes: list[str] | None
    budget_remaining: dict             # per_request, daily, monthly, session
    reasoning_tokens_used: int | None
    reasoning_tokens_budget: int | None
    anomaly_score: float
    anomaly_flagged: bool
    warnings: list[dict] | None        # Approaching limits

@dataclass
class SpendReport:
    agent_id: str
    period: str
    total_cost: float
    by_model: dict[str, float]
    by_day: list[dict]
    request_count: int
    avg_cost_per_request: float
    reasoning_tokens: int

from tealtiger import TealEngine, TealMonitor

engine = TealEngine(
    policy={
        "monitor": {
            "limits": {"per_request": 2.00, "daily_per_agent": 50.00},
            "reasoning_budget": {"enabled": True, "max_per_request": 10000},
            "anomaly_detection": {"enabled": True, "sensitivity": "medium", "on_anomaly": "approval_required"},
        }
    },
    modules=[TealMonitor(
        limits={"per_request": 2.00, "daily_per_agent": 50.00, "daily_global": 500.00},
        reasoning_budget={"enabled": True, "max_per_request": 10000, "daily_limit": 100000},
        anomaly_detection={"enabled": True, "sensitivity": "medium", "baseline_window": "7d", "on_anomaly": "approval_required"},
        attribution={"enabled": True, "group_by": "team"},
        cost_model={"pricing": {"gpt-4o": {"input_per_1m": 2.50, "output_per_1m": 10.00}}, "include_reasoning_tokens": True},
    )],
)