Trace

from latence import Latence

trace = Latence()   # reads LATENCE_TRACE_API_KEY from env

# --- 1. Score groundedness ---
ground = trace.grounding.rag(
    response_text="Paris is the capital of France.",
    raw_context="France's capital city is Paris.",
)
print(ground.score, ground.band)          # 0.92, "green"
print(ground.context_unused_ratio)        # 0.0 — no wasted context

# --- 2. Redact PII ---
privacy = trace.privacy.redact(text="Email me at john@acme.com")
print(privacy.redacted_text)              # "Email me at [EMAIL]"
print(privacy.entity_count)               # 1

# --- 3. Compress context ---
compressed = trace.compression.text(
    text="Our refund policy allows returns within 30 days of purchase. "
         "All items must be in original condition with receipt.",
)
print(compressed.compressed_text)         # shorter, same meaning
print(compressed.tokens_saved)            # 9

from latence import Latence, SupportUnit

trace = Latence()

units = [
    SupportUnit(text="Paris is the capital of France.", source_id="doc-42"),
    SupportUnit(text="It sits on the Seine.",           source_id="doc-42"),
    {"text": "Population: 2.1M.", "source_id": "wiki"},
]

r = trace.grounding.rag(
    response_text="Paris, France's capital, sits on the Seine.",
    support_units=units,
)

for u in (r.support_units or []):
    print(u.source_id, u.usage_state, u.coverage_score)
# doc-42  used       0.95
# doc-42  used       0.88
# wiki    unused     0.12

import asyncio
from latence import AsyncLatence

async def trace_pipeline(answer: str, context: str):
    async with AsyncLatence() as trace:
        ground, privacy, compressed = await asyncio.gather(
            trace.grounding.rag(
                response_text=answer,
                raw_context=context,
            ),
            trace.privacy.redact(text=answer),
            trace.compression.text(text=context),
        )
    return ground, privacy, compressed

ground, privacy, compressed = asyncio.run(
    trace_pipeline(
        answer="The patient's refund was processed on 2024-01-15.",
        context="Refund policy: 30-day window. Patient John Doe, case #4412.",
    )
)

print(f"Grounded: {ground.band} ({ground.score:.2f})")
print(f"Redacted: {privacy.redacted_text}")
print(f"Compressed: {compressed.tokens_saved} tokens saved")

from latence import Latence

trace = Latence()

def safe_answer(query: str, context: str, llm_answer: str) -> dict:
    """Score, redact, decide — all before the user sees anything."""
    
    result = trace.grounding.rag(
        response_text=llm_answer,
        raw_context=context,
    )

    # Autonomous decision based on band
    if result.band == "red":
        return {
            "action": "block",
            "reason": f"Groundedness {result.score:.2f} — answer not supported by context",
            "fallback": "I don't have enough information to answer that reliably.",
        }

    if result.band == "amber":
        return {
            "action": "review",
            "reason": f"Groundedness {result.score:.2f} — partially supported",
            "answer": llm_answer,
            "flag": "human_review_required",
        }

    # Green band — safe to serve, redact PII first
    clean = trace.privacy.redact(text=llm_answer)

    return {
        "action": "allow",
        "answer": clean.redacted_text,
        "score": result.score,
        "context_used": f"{(1 - result.context_unused_ratio) * 100:.0f}%",
        "entities_redacted": clean.entity_count,
    }

from latence import Latence

trace = Latence()

def traced_rag_call(query, context, answer):
    result = trace.grounding.rag(
        response_text=answer,
        raw_context=context,
        request_id=f"prod-{query[:20]}",   # your correlation ID
    )

    # Every call is automatically logged to your Trace dashboard.
    # The gateway records: score, band, latency, context ratios,
    # cost — all queryable in the Insights page.

    print(f"[Trace] {result.band} | score={result.score:.3f} "
          f"| unused={result.context_unused_ratio:.0%} "
          f"| latency={result.latency_ms:.0f}ms")

    return result