import OpenAI from 'openai';
import { wrapOpenAI, withSession, configure } from '@sentrial/sdk';

configure({ apiKey: 'sentrial_live_xxx' });

// Wrap once - all calls auto-tracked!
const openai = wrapOpenAI(new OpenAI());

const myAgent = withSession('support-agent', async (userId: string, message: string) => {
  // LLM calls automatically tracked with tokens, cost, latency
  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [{ role: 'user', content: message }],
  });
  return response.choices[0].message.content;
});

await myAgent('user_123', 'How do I reset my password?');

import { withTool, withSession, configure } from '@sentrial/sdk';

configure({ apiKey: 'sentrial_live_xxx' });

// Track tools
const searchKB = withTool('search_kb', async (query: string) => {
  return { articles: ['KB-001', 'KB-002'] };
});

// Track sessions
const supportAgent = withSession('support-agent', async (userId: string, message: string) => {
  const results = await searchKB(message); // Auto-tracked!
  return `Found ${results.articles.length} articles`;
});

import { configure, wrapAISDK } from '@sentrial/sdk';
import * as ai from 'ai';
import { openai } from '@ai-sdk/openai';

configure({ apiKey: process.env.SENTRIAL_API_KEY, defaultAgent: 'my-agent' });

const { generateText, streamText } = wrapAISDK(ai);

// All calls automatically traced!
const { text } = await generateText({
  model: openai('gpt-4'),
  prompt: 'What is the capital of France?',
});

import { wrapOpenAI, wrapAnthropic, wrapGoogle, wrapLLM } from '@sentrial/sdk';

// OpenAI
const openai = wrapOpenAI(new OpenAI());

// Anthropic
const anthropic = wrapAnthropic(new Anthropic());

// Google Gemini
const model = wrapGoogle(genAI.getGenerativeModel({ model: 'gemini-2.0-flash' }));

// Auto-detect
const client = wrapLLM(new OpenAI()); // Detects OpenAI, Anthropic, or Google

import { withTool, withSession, Tool, TrackSession } from '@sentrial/sdk';

// Higher-order functions
const searchWeb = withTool('web_search', async (query: string) => {...});
const myAgent = withSession('my-agent', async (userId, message) => {...});

// Class decorators (with experimentalDecorators)
class MyAgent {
  @Tool('search')
  async searchWeb(query: string) {...}

  @TrackSession('my-agent')
  async handleRequest(userId: string, message: string) {...}
}

import { Experiment, getSystemPrompt, isExperimentMode } from '@sentrial/sdk';

const experiment = new Experiment('exp_abc123');
await experiment.load();

await experiment.run(async (testCase, variant, tracker) => {
  const systemPrompt = getSystemPrompt('Default prompt');
  const response = await runAgent(testCase.userInput, systemPrompt);
  tracker.setResultSessionId(sessionId);
});

import { wrapAISDK } from '@sentrial/sdk';
import * as ai from 'ai';
import { z } from 'zod';

const { generateText, streamText, generateObject, streamObject } = wrapAISDK(ai);

// With tools
const { text } = await generateText({
  model: openai('gpt-4'),
  prompt: "What's the weather?",
  tools: {
    getWeather: {
      description: 'Get weather',
      parameters: z.object({ location: z.string() }),
      execute: async ({ location }) => ({ temp: 72 }), // Auto-tracked!
    },
  },
});

import { configure } from '@sentrial/sdk';

configure({
  apiKey: 'sentrial_live_xxx',
  apiUrl: 'https://api.sentrial.com', // Optional
});

import { SentrialClient } from '@sentrial/sdk';

const client = new SentrialClient({ apiKey: '...' });

// Create session
const sessionId = await client.createSession({
  name: 'Support Request',
  agentName: 'support-agent',
  userId: 'user_123',
});

// Track tool calls
await client.trackToolCall({
  sessionId,
  toolName: 'search_kb',
  toolInput: { query: 'password reset' },
  toolOutput: { articles: ['KB-001'] },
  reasoning: 'User asked about password reset',
});

// Track decisions
await client.trackDecision({
  sessionId,
  reasoning: 'Found relevant article, sharing with user',
  alternatives: ['Escalate', 'Ask clarifying question'],
  confidence: 0.9,
});

// Complete session
await client.completeSession({
  sessionId,
  success: true,
  customMetrics: { satisfaction: 4.5 },
  promptTokens: 1500,
  completionTokens: 500,
});

import { calculateOpenAICost, calculateAnthropicCost, calculateGoogleCost } from '@sentrial/sdk';

const cost = calculateOpenAICost({
  model: 'gpt-4o',
  inputTokens: 1000,
  outputTokens: 500,
});
// Returns: 0.0075