from brokle import Brokle, wrap_openai
import openai

# Initialize Brokle
client = Brokle(api_key="bk_...")

# Wrap OpenAI client
openai_client = wrap_openai(openai.OpenAI(), brokle=client)

# Use as normal - tracing is automatic
response = openai_client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is Python?"}
    ]
)

print(response.choices[0].message.content)
client.flush()

import { Brokle } from 'brokle';
import { wrapOpenAI } from 'brokle-openai';
import OpenAI from 'openai';

// Initialize Brokle
const brokle = new Brokle({ apiKey: 'bk_...' });

// Wrap OpenAI client
const openai = wrapOpenAI(new OpenAI(), { brokle });

// Use as normal - tracing is automatic
const response = await openai.chat.completions.create({
  model: 'gpt-4',
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'What is Python?' }
  ]
});

console.log(response.choices[0].message.content);
await brokle.shutdown();

from brokle import Brokle, wrap_anthropic
import anthropic

client = Brokle(api_key="bk_...")
claude = wrap_anthropic(anthropic.Anthropic(), brokle=client)

response = claude.messages.create(
    model="claude-3-sonnet-20240229",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain quantum computing"}
    ]
)

print(response.content[0].text)
client.flush()

import { Brokle } from 'brokle';
import { wrapAnthropic } from 'brokle-anthropic';
import Anthropic from '@anthropic-ai/sdk';

const brokle = new Brokle({ apiKey: 'bk_...' });
const claude = wrapAnthropic(new Anthropic(), { brokle });

const response = await claude.messages.create({
  model: 'claude-3-sonnet-20240229',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'Explain quantum computing' }
  ]
});

console.log(response.content[0].text);
await brokle.shutdown();

from brokle import Brokle, wrap_openai
import openai

client = Brokle(api_key="bk_...")
openai_client = wrap_openai(openai.OpenAI(), brokle=client)

# Streaming is automatically traced
stream = openai_client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Tell me a story"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

client.flush()

const stream = await openai.chat.completions.create({
  model: 'gpt-4',
  messages: [{ role: 'user', content: 'Tell me a story' }],
  stream: true
});

for await (const chunk of stream) {
  if (chunk.choices[0]?.delta?.content) {
    process.stdout.write(chunk.choices[0].delta.content);
  }
}

await brokle.shutdown();

from brokle import Brokle, wrap_openai
import openai
import asyncio

client = Brokle(api_key="bk_...")
openai_client = wrap_openai(openai.AsyncOpenAI(), brokle=client)

async def main():
    response = await openai_client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": "Hello!"}]
    )
    print(response.choices[0].message.content)

asyncio.run(main())
client.flush()

// JavaScript is async by default
const response = await openai.chat.completions.create({
  model: 'gpt-4',
  messages: [{ role: 'user', content: 'Hello!' }]
});

from brokle import Brokle, wrap_openai
import openai

client = Brokle(api_key="bk_...")
openai_client = wrap_openai(openai.OpenAI(), brokle=client)

# Manual span for the overall operation
with client.start_as_current_span(name="customer_inquiry") as span:
    # Add business context
    span.set_attribute("customer_tier", "enterprise")
    span.set_attribute("inquiry_type", "billing")
    span.update_trace(
        user_id="user_123",
        session_id="session_456"
    )

    # LLM call is automatically traced as a child span
    response = openai_client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": user_question}]
    )

    span.update(output=response.choices[0].message.content)

client.flush()

const span = brokle.startSpan({
  name: 'customer_inquiry',
  attributes: {
    customerTier: 'enterprise',
    inquiryType: 'billing',
    userId: 'user_123',
    sessionId: 'session_456'
  }
});

// LLM call is automatically traced as a child span
const response = await openai.chat.completions.create({
  model: 'gpt-4',
  messages: [{ role: 'user', content: userQuestion }]
});

span.end({ output: response.choices[0].message.content });
await brokle.shutdown();

from brokle import Brokle, wrap_openai
from brokle.integrations.openai import OpenAIConfig

config = OpenAIConfig(
    capture_input=True,       # Log prompts (default: True)
    capture_output=True,      # Log completions (default: True)
    capture_tokens=True,      # Track token usage (default: True)
    capture_cost=True,        # Calculate costs (default: True)
    mask_pii=False,           # Mask PII in logs (default: False)
)

openai_client = wrap_openai(
    openai.OpenAI(),
    brokle=client,
    config=config
)

const openai = wrapOpenAI(new OpenAI(), {
  brokle,
  config: {
    captureInput: true,
    captureOutput: true,
    captureTokens: true,
    captureCost: true,
    maskPii: false
  }
});