Integrations

class AnthropicClient implements LLMClient

// ── Inline types (no external imports needed) ──────────────────────────────

type LLMProvider = 'anthropic' | 'openai'

type LLMClientConfig = {
  model: string
  apiKey: string
  maxRetries?: number
}

type CompletionRequest = {
  messages: Array<{ role: 'user' | 'assistant'; content: string }>
  systemPrompt?: string
  maxTokens?: number
}

type CompletionResponse = {
  content: string
  model: string
  usage: { inputTokens: number; outputTokens: number }
}

// ── Simulated AnthropicClient (mirrors real implementation) ────────────────

class AnthropicClient {
  provider: LLMProvider = 'anthropic'
  private model: string
  private apiKey: string
  private maxRetries: number

  constructor(config: LLMClientConfig) {
    this.model = config.model
    this.apiKey = config.apiKey
    this.maxRetries = config.maxRetries ?? 3
  }

  async complete(request: CompletionRequest): Promise<CompletionResponse> {
    const body = {
      model: this.model,
      max_tokens: request.maxTokens ?? 1024,
      system: request.systemPrompt,
      messages: request.messages,
    }

    let lastError: Error | undefined

    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
      try {
        const response = await fetch('https://api.anthropic.com/v1/messages', {
          method: 'POST',
          headers: {
            'x-api-key': this.apiKey,
            'anthropic-version': '2023-06-01',
            'content-type': 'application/json',
          },
          body: JSON.stringify(body),
        })

        if (!response.ok) {
          throw new Error(`Anthropic API error: ${response.status} ${response.statusText}`)
        }

        const data = await response.json() as {
          content: Array<{ text: string }>
          model: string
          usage: { input_tokens: number; output_tokens: number }
        }

        return {
          content: data.content[0].text,
          model: data.model,
          usage: {
            inputTokens: data.usage.input_tokens,
            outputTokens: data.usage.output_tokens,
          },
        }
      } catch (error) {
        lastError = error instanceof Error ? error : new Error(String(error))
        if (attempt < this.maxRetries) {
          console.warn(`Attempt ${attempt} failed, retrying...`)
          await new Promise(resolve => setTimeout(resolve, 500 * attempt))
        }
      }
    }

    throw lastError
  }
}

// ── Usage example ──────────────────────────────────────────────────────────

const client = new AnthropicClient({
  apiKey: process.env.ANTHROPIC_API_KEY || 'your-anthropic-api-key',
  model: 'claude-3-5-sonnet-20241022',
  maxRetries: 3,
})

async function main() {
  try {
    const response = await client.complete({
      systemPrompt: 'You are a concise assistant. Reply in one sentence.',
      messages: [
        { role: 'user', content: 'What is the capital of Japan?' },
      ],
      maxTokens: 100,
    })

    console.log('Provider: ', client.provider)
    console.log('Model:    ', response.model)
    console.log('Reply:    ', response.content)
    console.log('Tokens:   ', response.usage)
    // Expected output:
    // Provider:  anthropic
    // Model:     claude-3-5-sonnet-20241022
    // Reply:     The capital of Japan is Tokyo.
    // Tokens:    { inputTokens: 28, outputTokens: 10 }
  } catch (error) {
    console.error('Completion failed after all retries:', error)
  }
}

main()

class OpenAICompatibleClient implements LLMClient

async complete(request: CompletionRequest): Promise<CompletionResponse>

// ── Inline types (no external imports needed) ──────────────────────────────

type MessageRole = 'system' | 'user' | 'assistant'

interface Message {
  role: MessageRole
  content: string
}

interface CompletionRequest {
  messages: Message[]
  model?: string
  maxTokens?: number
  temperature?: number
  stopSequences?: string[]
}

interface CompletionResponse {
  content: string
  model: string
  usage: {
    inputTokens: number
    outputTokens: number
  }
  stopReason: string
}

// ── Simulated AnthropicClient.complete implementation ──────────────────────

class AnthropicClient {
  private model: string
  private apiKey: string

  constructor(config: { apiKey: string; model?: string }) {
    this.apiKey = config.apiKey
    this.model = config.model || 'claude-3-5-sonnet-20241022'
  }

  isConfigured(): boolean {
    return true
  }

  async complete(request: CompletionRequest): Promise<CompletionResponse> {
    const model = request.model || this.model

    // Separate system message from conversation (mirrors real implementation)
    const systemMessage = request.messages.find(m => m.role === 'system')
    const conversationMessages = request.messages.filter(m => m.role !== 'system')

    // Build the Anthropic API payload
    const payload = {
      model,
      max_tokens: request.maxTokens ?? 1024,
      temperature: request.temperature ?? 0.7,
      ...(systemMessage && { system: systemMessage.content }),
      messages: conversationMessages.map(m => ({
        role: m.role,
        content: m.content,
      })),
      ...(request.stopSequences && { stop_sequences: request.stopSequences }),
    }

    const response = await fetch('https://api.anthropic.com/v1/messages', {
      method: 'POST',
      headers: {
        'x-api-key': this.apiKey,
        'anthropic-version': '2023-06-01',
        'content-type': 'application/json',
      },
      body: JSON.stringify(payload),
    })

    if (!response.ok) {
      const error = await response.json().catch(() => ({}))
      throw new Error(
        `Anthropic API error ${response.status}: ${(error as any).error?.message ?? response.statusText}`
      )
    }

    const data = await response.json() as any

    return {
      content: data.content[0]?.text ?? '',
      model: data.model,
      usage: {
        inputTokens: data.usage.input_tokens,
        outputTokens: data.usage.output_tokens,
      },
      stopReason: data.stop_reason,
    }
  }
}

// ── Usage example ──────────────────────────────────────────────────────────

const client = new AnthropicClient({
  apiKey: process.env.ANTHROPIC_API_KEY || 'your-anthropic-api-key',
  model: 'claude-3-5-sonnet-20241022',
})

async function main() {
  try {
    const response = await client.complete({
      messages: [
        {
          role: 'system',
          content: 'You are a concise assistant. Reply in one sentence.',
        },
        {
          role: 'user',
          content: 'What is the capital of Japan?',
        },
      ],
      maxTokens: 256,
      temperature: 0.3,
    })

    console.log('Reply:      ', response.content)
    console.log('Model:      ', response.model)
    console.log('Stop reason:', response.stopReason)
    console.log('Tokens used:', response.usage)

    // Expected output:
    // Reply:       The capital of Japan is Tokyo.
    // Model:       claude-3-5-sonnet-20241022
    // Stop reason: end_turn
    // Tokens used: { inputTokens: 32, outputTokens: 9 }
  } catch (error) {
    console.error('Completion failed:', error instanceof Error ? error.message : error)
    process.exit(1)
  }
}

main()

async complete(request: CompletionRequest): Promise<CompletionResponse>

import OpenAI from 'openai'

// --- Inline types (do not import from library) ---
interface Message {
  role: 'system' | 'user' | 'assistant'
  content: string
}

interface CompletionRequest {
  messages: Message[]
  model?: string
  temperature?: number
  maxTokens?: number
  systemPrompt?: string
}

interface CompletionResponse {
  content: string
  model: string
  usage: {
    promptTokens: number
    completionTokens: number
    totalTokens: number
  }
}

// --- Inline OpenAI-compatible client implementation ---
class OpenAICompatibleClient {
  private client: OpenAI
  private model: string

  constructor(config: { apiKey: string; baseURL?: string; defaultModel?: string }) {
    this.client = new OpenAI({
      apiKey: config.apiKey,
      baseURL: config.baseURL,
    })
    this.model = config.defaultModel || 'gpt-4o-mini'
  }

  async complete(request: CompletionRequest): Promise<CompletionResponse> {
    const model = request.model || this.model

    const messages: Message[] = []

    if (request.systemPrompt) {
      messages.push({ role: 'system', content: request.systemPrompt })
    }

    messages.push(...request.messages)

    const response = await this.client.chat.completions.create({
      model,
      messages,
      temperature: request.temperature ?? 0.7,
      max_tokens: request.maxTokens,
    })

    const choice = response.choices[0]

    return {
      content: choice.message.content ?? '',
      model: response.model,
      usage: {
        promptTokens: response.usage?.prompt_tokens ?? 0,
        completionTokens: response.usage?.completion_tokens ?? 0,
        totalTokens: response.usage?.total_tokens ?? 0,
      },
    }
  }
}

// --- Usage example ---
const client = new OpenAICompatibleClient({
  apiKey: process.env.OPENAI_API_KEY || 'sk-your-api-key-here',
  defaultModel: 'gpt-4o-mini',
  // Swap baseURL to use Groq, Together AI, etc.:
  // baseURL: 'https://api.groq.com/openai/v1'
})

async function main() {
  try {
    const response = await client.complete({
      systemPrompt: 'You are a concise assistant. Reply in one sentence.',
      messages: [
        { role: 'user', content: 'What is the capital of Japan?' },
      ],
      temperature: 0.3,
      maxTokens: 60,
    })

    console.log('Generated text:', response.content)
    // Output: "The capital of Japan is Tokyo."

    console.log('Model used:', response.model)
    // Output: "gpt-4o-mini"

    console.log('Token usage:', response.usage)
    // Output: { promptTokens: 28, completionTokens: 10, totalTokens: 38 }
  } catch (error) {
    if (error instanceof Error) {
      console.error('Completion failed:', error.message)
      // Common causes: invalid API key, unknown model name, rate limit exceeded
    }
  }
}

main()

constructor(config: LLMClientConfig)

// Inline type definitions (do not import from skrypt)
type LLMProvider = 'anthropic' | 'openai'

interface LLMClientConfig {
  apiKey: string
  model: string
  maxRetries?: number
}

interface CompletionRequest {
  prompt: string
  maxTokens?: number
}

interface CompletionResponse {
  text: string
  usage?: { inputTokens: number; outputTokens: number }
}

// Simulated AnthropicClient (mirrors the real implementation)
class AnthropicClient {
  provider: LLMProvider = 'anthropic'
  private model: string
  private maxRetries: number
  private apiKey: string

  constructor(config: LLMClientConfig) {
    if (!config.apiKey) throw new Error('apiKey is required')
    if (!config.model) throw new Error('model is required')

    this.apiKey = config.apiKey
    this.model = config.model
    this.maxRetries = config.maxRetries ?? 3
  }

  // Simulated completion method
  async complete(request: CompletionRequest): Promise<CompletionResponse> {
    console.log(`[${this.provider}] Sending request to model: ${this.model}`)
    console.log(`[${this.provider}] Max retries configured: ${this.maxRetries}`)
    console.log(`[${this.provider}] Prompt: "${request.prompt}"`)

    // Simulated response (real client would call Anthropic API here)
    return {
      text: `Simulated response from ${this.model}`,
      usage: { inputTokens: 12, outputTokens: 8 },
    }
  }
}

// --- Usage Example ---

async function main() {
  try {
    // Initialize the client with your Anthropic credentials
    const client = new AnthropicClient({
      apiKey: process.env.ANTHROPIC_API_KEY || 'sk-ant-your-api-key-here',
      model: 'claude-3-5-sonnet-20241022',
      maxRetries: 5, // optional, defaults to 3
    })

    console.log('Provider:', client.provider)
    // Output: Provider: anthropic

    const response = await client.complete({
      prompt: 'Explain recursion in one sentence.',
      maxTokens: 100,
    })

    console.log('Response:', response.text)
    // Output: Response: Simulated response from claude-3-5-sonnet-20241022

    console.log('Token usage:', response.usage)
    // Output: Token usage: { inputTokens: 12, outputTokens: 8 }
  } catch (error) {
    if (error instanceof Error) {
      console.error('Failed to initialize AnthropicClient:', error.message)
    }
  }
}

main()

constructor(config: LLMClientConfig)

// ── Inline types (no external imports needed) ──────────────────────────────

type LLMProvider = 'openai' | 'anthropic' | 'azure' | 'ollama' | string

interface LLMClientConfig {
  provider: LLMProvider
  model: string
  apiKey: string
  baseUrl?: string
  maxRetries?: number
}

interface CompletionRequest {
  messages: { role: 'system' | 'user' | 'assistant'; content: string }[]
  temperature?: number
  maxTokens?: number
}

interface CompletionResponse {
  content: string
  usage?: { promptTokens: number; completionTokens: number }
}

// ── Provider default URLs (mirrors PROVIDER_BASE_URLS) ─────────────────────

const PROVIDER_BASE_URLS: Record<string, string> = {
  openai: 'https://api.openai.com/v1',
  anthropic: 'https://api.anthropic.com/v1',
  ollama: 'http://localhost:11434/v1',
}

// ── Simulated OpenAICompatibleClient ──────────────────────────────────────

class OpenAICompatibleClient {
  provider: LLMProvider
  private model: string
  private maxRetries: number
  private baseUrl: string
  private apiKey: string

  constructor(config: LLMClientConfig) {
    this.provider = config.provider
    this.model = config.model
    this.maxRetries = config.maxRetries ?? 3
    this.apiKey = config.apiKey
    this.baseUrl = config.baseUrl || PROVIDER_BASE_URLS[config.provider] || ''

    console.log(`[OpenAICompatibleClient] Initialized`)
    console.log(`  Provider : ${this.provider}`)
    console.log(`  Model    : ${this.model}`)
    console.log(`  Base URL : ${this.baseUrl}`)
    console.log(`  Retries  : ${this.maxRetries}`)
  }

  async complete(request: CompletionRequest): Promise<CompletionResponse> {
    // Simulated response — replace with real OpenAI SDK call in production
    const lastMessage = request.messages.at(-1)?.content ?? ''
    return {
      content: `[Simulated response to: "${lastMessage}"]`,
      usage: { promptTokens: 12, completionTokens: 20 },
    }
  }
}

// ── Example 1: Standard OpenAI setup ──────────────────────────────────────

async function main() {
  try {
    const client = new OpenAICompatibleClient({
      provider: 'openai',
      model: 'gpt-4o',
      apiKey: process.env.OPENAI_API_KEY || 'sk-your-api-key-here',
      maxRetries: 3,
    })

    const response = await client.complete({
      messages: [
        { role: 'system', content: 'You are a helpful assistant.' },
        { role: 'user', content: 'What is the capital of France?' },
      ],
      temperature: 0.7,
    })

    console.log('\n[Response]', response.content)
    console.log('[Usage]', response.usage)
    // Output: [Response] [Simulated response to: "What is the capital of France?"]
    // Output: [Usage]    { promptTokens: 12, completionTokens: 20 }

    // ── Example 2: Local Ollama model with custom base URL ─────────────────

    const localClient = new OpenAICompatibleClient({
      provider: 'ollama',
      model: 'llama3.2',
      apiKey: 'ollama', // Ollama doesn't require a real key
      baseUrl: 'http://localhost:11434/v1', // explicit override
      maxRetries: 1,
    })

    console.log('\n[Local provider]', localClient.provider)
    // Output: [Local provider] ollama

  } catch (error) {
    console.error('Failed to initialize or call client:', error)
  }
}

main()

isConfigured(): boolean

// Inline types to simulate AnthropicClient behavior
interface LLMClientConfig {
  apiKey: string
  model?: string
  timeout?: number
  maxRetries?: number
}

// Simulated AnthropicClient class (self-contained, no external imports)
class AnthropicClient {
  private apiKey: string
  private model: string
  private timeout: number
  private maxRetries: number

  constructor(config: LLMClientConfig) {
    this.apiKey = config.apiKey
    this.model = config.model ?? 'claude-3-5-sonnet-20241022'
    this.timeout = config.timeout ?? 60000
    this.maxRetries = config.maxRetries ?? 2
  }

  isConfigured(): boolean {
    return true // Anthropic SDK handles validation
  }
}

// --- Usage Example ---

const client = new AnthropicClient({
  apiKey: process.env.ANTHROPIC_API_KEY || 'sk-ant-your-api-key-here',
  model: 'claude-3-5-sonnet-20241022',
  timeout: 30000,
})

async function runCompletion() {
  try {
    // Guard against unconfigured clients before making requests
    if (!client.isConfigured()) {
      throw new Error('AnthropicClient is not configured. Check your API key and settings.')
    }

    console.log('Client configured:', client.isConfigured())
    // Output: Client configured: true

    console.log('Proceeding with API request...')
    // In real usage, you would call client.complete({ prompt: '...' }) here

  } catch (error) {
    console.error('Client setup error:', error instanceof Error ? error.message : error)
  }
}

runCompletion()

isConfigured(): boolean

// Inline the minimal interface and class needed to demonstrate isConfigured()
interface LLMClientConfig {
  apiKey: string
  model?: string
  baseURL?: string
  maxRetries?: number
}

// Simulated OpenAICompatibleClient with isConfigured behavior
class OpenAICompatibleClient {
  private apiKey: string
  private model: string
  private baseURL?: string
  private maxRetries: number

  constructor(config: LLMClientConfig) {
    this.apiKey = config.apiKey
    this.model = config.model || 'gpt-4o'
    this.baseURL = config.baseURL
    this.maxRetries = config.maxRetries ?? 3
  }

  // Always returns true — OpenAI SDK handles validation internally
  isConfigured(): boolean {
    return true
  }
}

// --- Usage Example ---

const client = new OpenAICompatibleClient({
  apiKey: process.env.OPENAI_API_KEY || 'sk-your-api-key-here',
  model: 'gpt-4o',
  maxRetries: 2
})

try {
  // Guard clause: check before attempting any completions
  if (!client.isConfigured()) {
    throw new Error('LLM client is not configured — cannot proceed.')
  }

  console.log('Client configured:', client.isConfigured())
  // Output: Client configured: true

  console.log('Proceeding to make completion requests...')
  // Output: Proceeding to make completion requests...
} catch (error) {
  console.error('Configuration check failed:', error)
}