LLM Integrations

from agent_sentinel.integrations import instrument_openai
from openai import OpenAI

# Instrument OpenAI (one-time setup)
instrument_openai()

# Use OpenAI normally - automatically tracked
client = OpenAI(api_key="sk-...")

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "What is 2+2?"}]
)

# Automatically logged with:
# - action_name: "openai_chat_completion"
# - cost: $0.015 (calculated from token usage)
# - input_tokens: 10
# - output_tokens: 5
# - model: "gpt-4o"
# - duration: ~500ms

from openai import AsyncOpenAI

client = AsyncOpenAI(api_key="sk-...")

# Automatically tracked
response = await client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Hello!"}]
)

from agent_sentinel.integrations import instrument_anthropic
from anthropic import Anthropic

# Instrument Anthropic (one-time setup)
instrument_anthropic()

# Use Anthropic normally - automatically tracked
client = Anthropic(api_key="sk-ant-...")

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[{"role": "user", "content": "What is 2+2?"}]
)

# Automatically logged with:
# - action_name: "anthropic_messages_create"
# - cost: $0.008 (calculated from token usage)
# - input_tokens: 10
# - output_tokens: 5
# - model: "claude-3-5-sonnet-20241022"

from anthropic import AsyncAnthropic

client = AsyncAnthropic(api_key="sk-ant-...")

response = await client.messages.create(
    model="claude-3-5-haiku-20241022",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}]
)

from agent_sentinel.integrations import instrument_grok
from openai import OpenAI  # Grok uses OpenAI SDK

# Instrument Grok (one-time setup)
instrument_grok()

# Use Grok via OpenAI SDK
client = OpenAI(
    api_key="xai-...",
    base_url="https://api.x.ai/v1"
)

response = client.chat.completions.create(
    model="grok-beta",
    messages=[{"role": "user", "content": "What is 2+2?"}]
)

from agent_sentinel.integrations import instrument_gemini
import google.generativeai as genai

# Instrument Gemini (one-time setup)
instrument_gemini()

# Use Gemini normally
genai.configure(api_key="AIza...")
model = genai.GenerativeModel('gemini-pro')

response = model.generate_content("What is 2+2?")

from agent_sentinel import PolicyEngine
from agent_sentinel.guardrails import ModerationRule, GeminiModerator

PolicyEngine.configure(
    moderation_rule=ModerationRule(moderator=GeminiModerator()),
)

from agent_sentinel.integrations import get_token_costs

# Get total costs by provider
costs = get_token_costs()

print(f"OpenAI: ${costs['openai']:.4f}")
print(f"Anthropic: ${costs['anthropic']:.4f}")
print(f"Grok: ${costs['grok']:.4f}")
print(f"Gemini: ${costs['gemini']:.4f}")
print(f"Total: ${costs['total']:.4f}")

from agent_sentinel.integrations.pricing import ModelPricing, PRICING_DATA

# Add custom model pricing
PRICING_DATA["openai"]["my-custom-model"] = ModelPricing(
    input_price_per_1m=5.0,
    output_price_per_1m=20.0
)

from agent_sentinel import guarded_action
from agent_sentinel.integrations import instrument_openai
from openai import OpenAI

instrument_openai()
client = OpenAI()

@guarded_action(name="agent_reasoning", cost_usd=0.0)
def run_agent(task):
    # Manual action wrapping
    result = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": task}]
    )
    # LLM call automatically tracked WITHIN this action
    return result.choices[0].message.content

# Ledger will show:
# 1. "agent_reasoning" action (manual)
# 2. "openai_chat_completion" action (automatic, nested)

from agent_sentinel import PolicyEngine
from agent_sentinel.integrations import instrument_openai
from openai import OpenAI

# Set budget
PolicyEngine.configure(session_budget=1.0)

instrument_openai()
client = OpenAI()

# First few calls succeed
for i in range(10):
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": f"Task {i}"}]
    )
    # Each call costs ~$0.10
    # After 10 calls, BudgetExceededError is raised

{
  "uuid": "a1b2c3d4...",
  "timestamp": "2024-12-28T10:30:00.123456Z",
  "action": "openai_chat_completion",
  "cost_usd": 0.0155,
  "duration_ns": 523000000,
  "outcome": "success",
  "tags": ["llm", "openai"],
  "inputs": {
    "model": "gpt-4o",
    "messages": [{"role": "user", "content": "What is 2+2?"}],
    "max_tokens": 1024
  },
  "outputs": {
    "content": "2 + 2 equals 4.",
    "input_tokens": 10,
    "output_tokens": 5,
    "total_tokens": 15,
    "finish_reason": "stop"
  }
}

# ✅ Correct order
instrument_openai()
client = OpenAI()

# ❌ Wrong order
client = OpenAI()
instrument_openai()  # Too late!

from agent_sentinel.integrations.pricing import normalize_model_name

print(normalize_model_name("gpt-4o-2024-05-13"))  # "gpt-4o"