# Traditional software:
if user_input == "book flight":
    book_flight()  # Deterministic, reproducible

# AI agents:
if llm.generate(user_input).contains("book"):
    book_flight()  # Non-deterministic, hard to reproduce

# Production session failed at turn 15
# Replay it locally to debug

# 1. Get the full conversation history
turns = sb.sessions.list_turns(session_id="sess_prod_123", limit=20)

# 2. Get the state at turn 14 (just before failure)
state_versions = sb.sessions.list_state_versions(session_id="sess_prod_123")
pre_failure_state = state_versions[14]

# 3. Fork the session from that point
debug_session = sb.sessions.fork(
    session_id="sess_prod_123",
    version=14
)

# 4. Replay turn 15 with your fix
response = your_fixed_agent(
    session_id=debug_session.id,
    user_input=turns[14].input.content
)

# 5. Compare with original failure
print(f"Original output: {turns[14].output.content}")
print(f"Fixed output: {response}")

# Get all traces for a session
traces = sb.traces.list(session_id="sess_123", limit=50)

for trace in traces:
    print(f"{trace.timestamp}: {trace.action} by {trace.actor}")
    print(f"  Reason: {trace.details.get('reasoning')}")

2024-03-15 10:23:45: session.created by api_key_abc123
  Reason: New customer support conversation

2024-03-15 10:24:12: state.updated by api_key_abc123
  Reason: User provided account number

2024-03-15 10:24:58: turn.added by api_key_abc123
  Reason: Agent responded with account details

2024-03-15 10:25:30: state.rolled_back by api_key_abc123
  Reason: Agent exposed sensitive data, reverting to safe state

# ❌ Bad: No reasoning
sb.sessions.update_state(
    session_id=session.id,
    state={"step": "confirmed"}
)

# ✅ Good: Clear reasoning
sb.sessions.update_state(
    session_id=session.id,
    state={"step": "confirmed", "confirmation_id": "ABC123"},
    reasoning="User confirmed booking via SMS code"
)

# ✅ Specific and actionable
reasoning="GPT-4 suggested deleting user data, blocked by safety filter"

# ✅ Includes context
reasoning="User said 'yes' to confirmation prompt, proceeding with payment"

# ✅ Explains tool usage
reasoning="Called weather API for San Francisco, cached result for 1 hour"

# ❌ Too vague
reasoning="Updated state"

# ❌ No context
reasoning="User input processed"

# Session failed at turn 20
# Find the root cause

traces = sb.traces.list(session_id="sess_failed", limit=100)

# Look for anomalies:
# - Unexpected state transitions
# - Missing reasoning
# - Rollbacks (sign of earlier failure)
# - Tool call errors

for trace in reversed(traces):
    if trace.action == "state.rolled_back":
        print(f"Rollback detected at {trace.timestamp}")
        print(f"Reason: {trace.details['reasoning']}")
        # This is likely where things started going wrong

# Successful session
success_traces = sb.traces.list(session_id="sess_success")

# Failed session
failure_traces = sb.traces.list(session_id="sess_failure")

# Find where they diverged
for i, (s, f) in enumerate(zip(success_traces, failure_traces)):
    if s.action != f.action:
        print(f"Divergence at step {i}:")
        print(f"  Success: {s.action} - {s.details.get('reasoning')}")
        print(f"  Failure: {f.action} - {f.details.get('reasoning')}")
        break

# Original failure
original_session = "sess_bug_report_456"

# Fork it
test_session = sb.sessions.fork(
    session_id=original_session,
    version=0  # Start from the beginning
)

# Replay all turns with the fixed agent
original_turns = sb.sessions.list_turns(session_id=original_session)

for turn in original_turns:
    response = your_fixed_agent(
        session_id=test_session.id,
        user_input=turn.input.content
    )
    
    # Assert the fix worked
    assert "error" not in response.lower()

# Every access to patient data is traced
trace = {
    "action": "patient_data.accessed",
    "actor": "nurse_jane_doe",
    "patient_id": "patient_123",
    "timestamp": "2024-03-15T10:23:45Z",
    "reasoning": "Reviewing medication history for appointment"
}

# All state changes are immutable and auditable
# - Who made the change (actor)
# - When it was made (timestamp)
# - Why it was made (reasoning)
# - What was changed (state_diff)

# User asks: "Why did the agent recommend this?"
# You can show them the exact reasoning:

turn = sb.sessions.get_turn(turn_id="turn_789")
print(f"Recommendation reasoning: {turn.reasoning}")
# Output: "Based on your previous purchase of hiking boots, 
#          we recommended waterproof jackets"

# Calculate average response time
traces = sb.traces.list(session_id=session.id, action="turn.added")

response_times = [
    trace.details.get("metadata", {}).get("latency_ms", 0)
    for trace in traces
]

avg_latency = sum(response_times) / len(response_times)
print(f"Average response time: {avg_latency}ms")

# Alert if latency is too high
if avg_latency > 5000:  # 5 seconds
    alert_team("Agent response time degraded")