import Anthropic from '@anthropic-ai/sdk';
import { createTollgateClient, wrapAnthropic } from '@tollgateai/sdk';

const tollgate = createTollgateClient(); // reads TOLLGATE_API_KEY
const anthropic = wrapAnthropic(new Anthropic(), tollgate, {
  customerId: 'cust_acme',
  runId: 'ticket_8842',
  agentId: 'support-agent',  // optional
});

const msg = await anthropic.messages.create({
  model: 'claude-opus-4-8',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Hello' }],
});

import OpenAI from 'openai';
import { createTollgateClient, wrapOpenAI } from '@tollgateai/sdk';

const tollgate = createTollgateClient();
const openai = wrapOpenAI(new OpenAI(), tollgate, {
  customerId: 'cust_acme',
  runId: 'ticket_8842',
});

const res = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Hello' }],
});

import OpenAI from 'openai';
import { createTollgateClient, wrapOpenAI } from '@tollgateai/sdk';

const tollgate = createTollgateClient();

// Groq
const groq = wrapOpenAI(
  new OpenAI({ baseURL: 'https://api.groq.com/openai/v1', apiKey: process.env.GROQ_API_KEY }),
  tollgate,
  { customerId: 'cust_acme', runId: 'ticket_8842', provider: 'openai_compatible' },
);

// OpenRouter
const openrouter = wrapOpenAI(
  new OpenAI({ baseURL: 'https://openrouter.ai/api/v1', apiKey: process.env.OPENROUTER_API_KEY }),
  tollgate,
  { customerId: 'cust_acme', runId: 'ticket_8842', provider: 'openai_compatible' },
);

import { GoogleGenAI } from '@google/genai';
import { createTollgateClient, wrapGemini } from '@tollgateai/sdk';

const tollgate = createTollgateClient();
const gemini = wrapGemini(
  new GoogleGenAI({ apiKey: process.env.GOOGLE_API_KEY }),
  tollgate,
  { customerId: 'cust_acme', runId: 'ticket_8842' },
);

const res = await gemini.models.generateContent({
  model: 'gemini-2.5-pro',
  contents: [{ role: 'user', parts: [{ text: 'Hello' }] }],
});

import { BedrockRuntimeClient } from '@aws-sdk/client-bedrock-runtime';
import { createTollgateClient, wrapBedrock } from '@tollgateai/sdk';

const tollgate = createTollgateClient();
const bedrock = wrapBedrock(
  new BedrockRuntimeClient({ region: 'us-east-1' }),
  tollgate,
  { customerId: 'cust_acme', runId: 'ticket_8842' },
);

// Use bedrock exactly as before — InvokeModel / stream.

const stream = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Hello' }],
  stream: true,
  stream_options: { include_usage: true }, // required for Tollgate
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
}
// Tollgate fires the tracking event after the stream closes.

await tollgate.resolve({
  runId: 'ticket_8842',
  customerId: 'cust_acme',
  outcome: 'resolved',       // 'resolved' | 'escalated' | 'failed'
  revenueUnitCents: 50,      // $0.50 per resolved ticket — overrides plan default
});

const startTime = Date.now();
const response = await rawAnthropicClient.messages.create({ ... });

await tollgate.track({
  customerId: 'cust_acme',
  runId: 'ticket_8842',
  provider: 'anthropic',
  model: 'claude-opus-4-8',
  tokensIn: response.usage.input_tokens,
  tokensOut: response.usage.output_tokens,
  reasoningTokens: response.usage.cache_creation_input_tokens ?? 0,
  cachedTokens: response.usage.cache_read_input_tokens ?? 0,
  idempotencyKey: `ticket_8842#step_1`, // unique per event — prevents double-counting
  latencyMs: Date.now() - startTime,
});

await tollgate.upsertCustomer({
  externalId: 'cust_acme',    // must match customerId used in track/wrap
  name: 'Acme Corp',
  plan: {
    name: 'Growth',
    pricingModel: 'per_unit',   // 'per_unit' | 'per_resolution' | 'usage_based' | 'per_seat' | 'flat' | 'hybrid'
    unitRevenueCents: 50,       // $0.50 per resolved ticket
    baseRevenueCents: 0,
  },
});