AI Providers 🤖

import ProtectMyAPI
 
// Make sure ProtectMyAPI is initialized first!
// ProtectMyAPI.shared.configure(appId: "your-app-id")
 
// Then use any AI provider:
let openai = ProtectMyAPI.openAIService()
let answer = try await openai.chat(
    message: "Hello! What can you do?",
    model: "gpt-4o-mini"
)
print(answer)

import com.protectmyapi.ai.ProtectMyAPIAI
 
// Make sure ProtectMyAPI is initialized first!
// ProtectMyAPI.initialize(context, "your-app-id")
 
// Then use any AI provider:
val openai = ProtectMyAPIAI.openAIService()
val answer = openai.chat(
    message = "Hello! What can you do?",
    model = "gpt-4o-mini"
)
println(answer)

import 'package:protectmyapi/protectmyapi_ai.dart';
 
// Make sure ProtectMyAPI is initialized first!
// await ProtectMyAPI.initialize("your-app-id");
 
// Then use any AI provider:
final openai = ProtectMyAPIAI.openAIService();
final answer = await openai.chat(
    message: "Hello! What can you do?",
    model: "gpt-4o-mini",
);
print(answer);

let gemini = ProtectMyAPI.geminiService()
 
// Simple text generation
let text = try await gemini.generateText(
    prompt: "Write a haiku about coding",
    systemInstruction: "You are a creative poet",
    maxTokens: 100
)
 
// Full request with all options
let request = GeminiGenerateContentRequest(
    contents: [
        GeminiContent(parts: [.text("Analyze this data")])
    ],
    generationConfig: GeminiGenerationConfig(
        maxOutputTokens: 1024,
        temperature: 0.7
    ),
    safetySettings: GeminiSafetySettings.permissive
)
let response = try await gemini.generateContent(body: request, model: "gemini-2.0-flash")
print(response.text ?? "")

val gemini = ProtectMyAPIAI.geminiService()
 
// Simple text generation
val text = gemini.generateText(
    prompt = "Write a haiku about coding",
    systemInstruction = "You are a creative poet",
    maxTokens = 100
)
 
// Full request with all options
val request = GeminiGenerateContentRequest(
    contents = listOf(
        GeminiContent(parts = listOf(GeminiPart.Text("Analyze this data")))
    ),
    generationConfig = GeminiGenerationConfig(
        maxOutputTokens = 1024,
        temperature = 0.7
    ),
    safetySettings = GeminiSafetySettings.permissive
)
val response = gemini.generateContent(request, "gemini-2.0-flash")
println(response.text ?: "")

final gemini = ProtectMyAPIAI.geminiService();
 
// Simple text generation
final text = await gemini.generateText(
    prompt: "Write a haiku about coding",
    systemInstruction: "You are a creative poet",
    maxTokens: 100,
);
 
// Full request with all options
final request = GeminiGenerateContentRequest(
    contents: [
        GeminiContent(parts: [GeminiPart.text("Analyze this data")])
    ],
    generationConfig: GeminiGenerationConfig(
        maxOutputTokens: 1024,
        temperature: 0.7,
    ),
    safetySettings: GeminiSafetySettings.permissive,
);
final response = await gemini.generateContent(body: request, model: "gemini-2.0-flash");
print(response.text ?? "");

let gemini = ProtectMyAPI.geminiService()
 
// Load image data
guard let imageData = UIImage(named: "photo")?.jpegData(compressionQuality: 0.8) else { return }
 
let response = try await gemini.analyzeImage(
    prompt: "What do you see in this image?",
    imageData: imageData,
    mimeType: "image/jpeg"
)
print(response.text ?? "")

val gemini = ProtectMyAPIAI.geminiService()
 
// Load image data
val imageData: ByteArray = loadImageData()
 
val response = gemini.analyzeImage(
    prompt = "What do you see in this image?",
    imageData = imageData,
    mimeType = "image/jpeg"
)
println(response.text ?: "")

final gemini = ProtectMyAPIAI.geminiService();
 
// Load image data
final Uint8List imageData = await loadImageData();
 
final response = await gemini.analyzeImage(
    prompt: "What do you see in this image?",
    imageData: imageData,
    mimeType: "image/jpeg",
);
print(response.text ?? "");

let gemini = ProtectMyAPI.geminiService()
 
let audioURL = Bundle.main.url(forResource: "recording", withExtension: "m4a")!
let audioData = try Data(contentsOf: audioURL)
 
let transcript = try await gemini.transcribeAudio(
    audioData: audioData,
    mimeType: "audio/mp4"
)
print(transcript)

val gemini = ProtectMyAPIAI.geminiService()
 
val audioData: ByteArray = loadAudioFile()
 
val transcript = gemini.transcribeAudio(
    audioData = audioData,
    mimeType = "audio/mp4"
)
println(transcript)

final gemini = ProtectMyAPIAI.geminiService();
 
final Uint8List audioData = await loadAudioFile();
 
final transcript = await gemini.transcribeAudio(
    audioData: audioData,
    mimeType: "audio/mp4",
);
print(transcript);

let gemini = ProtectMyAPI.geminiService()
 
// Create a chat session
let chat = gemini.chat(
    systemInstruction: "You are a helpful coding assistant",
    model: "gemini-2.0-flash"
)
 
// Have a conversation
let response1 = try await chat.send("What is Swift?")
print("Assistant: \(response1)")
 
let response2 = try await chat.send("Show me a simple example")
print("Assistant: \(response2)")
 
// Clear history if needed
chat.clearHistory()

val gemini = ProtectMyAPIAI.geminiService()
 
// Create a chat session
val chat = gemini.chat(
    systemInstruction = "You are a helpful coding assistant",
    model = "gemini-2.0-flash"
)
 
// Have a conversation
val response1 = chat.send("What is Kotlin?")
println("Assistant: $response1")
 
val response2 = chat.send("Show me a simple example")
println("Assistant: $response2")
 
// Clear history if needed
chat.clearHistory()

final gemini = ProtectMyAPIAI.geminiService();
 
// Create a chat session
final chat = gemini.chat(
    systemInstruction: "You are a helpful coding assistant",
    model: "gemini-2.0-flash",
);
 
// Have a conversation
final response1 = await chat.send("What is Dart?");
print("Assistant: $response1");
 
final response2 = await chat.send("Show me a simple example");
print("Assistant: $response2");
 
// Clear history if needed
chat.clearHistory();

let gemini = ProtectMyAPI.geminiService()
 
// Define the schema
let schema: [String: ProtectMyAPIJSONValue] = [
    "type": "array",
    "items": [
        "type": "object",
        "properties": [
            "name": ["type": "string"],
            "ingredients": ["type": "array", "items": ["type": "string"]]
        ]
    ]
]
 
// Get structured output
let data = try await gemini.generateStructuredOutput(
    prompt: "List 3 simple recipes",
    schema: schema
)
 
// Or decode directly to a type
struct Recipe: Decodable {
    let name: String
    let ingredients: [String]
}
 
let recipes: [Recipe] = try await gemini.generateStructuredOutput(
    prompt: "List 3 simple recipes",
    type: [Recipe].self,
    schema: schema
)

val gemini = ProtectMyAPIAI.geminiService()
 
val request = GeminiGenerateContentRequest(
    contents = listOf(
        GeminiContent(parts = listOf(GeminiPart.Text("List 3 simple recipes")))
    ),
    generationConfig = GeminiGenerationConfig(
        responseMimeType = "application/json",
        responseSchema = mapOf(
            "type" to JsonPrimitive("array"),
            "items" to JsonObject(mapOf(
                "type" to JsonPrimitive("object"),
                "properties" to JsonObject(mapOf(
                    "name" to JsonObject(mapOf("type" to JsonPrimitive("string"))),
                    "ingredients" to JsonObject(mapOf(
                        "type" to JsonPrimitive("array"),
                        "items" to JsonObject(mapOf("type" to JsonPrimitive("string")))
                    ))
                ))
            ))
        )
    )
)
 
val response = gemini.generateContent(request, "gemini-2.0-flash")
val json = response.text // Parse as needed

final gemini = ProtectMyAPIAI.geminiService();
 
final request = GeminiGenerateContentRequest(
    contents: [
        GeminiContent(parts: [GeminiPart.text("List 3 simple recipes")])
    ],
    generationConfig: GeminiGenerationConfig(
        responseMimeType: "application/json",
        responseSchema: {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "ingredients": {"type": "array", "items": {"type": "string"}}
                }
            }
        },
    ),
);
 
final response = await gemini.generateContent(body: request, model: "gemini-2.0-flash");
final json = jsonDecode(response.text!); // Parse as needed

let openai = ProtectMyAPI.openAIService()
 
// Simple chat
let response = try await openai.chat(
    message: "Explain machine learning",
    model: "gpt-4o-mini",
    systemPrompt: "You are a teacher"
)
 
// Multi-turn conversation
let chat = openai.chatSession(model: "gpt-4o-mini", systemPrompt: "You are helpful")
let reply1 = try await chat.send("Hello!")
let reply2 = try await chat.send("Tell me a joke")

val openai = ProtectMyAPIAI.openAIService()
 
// Simple chat
val response = openai.chat(
    message = "Explain machine learning",
    model = "gpt-4o-mini",
    systemPrompt = "You are a teacher"
)
 
// Multi-turn conversation
val chat = openai.chatSession(model = "gpt-4o-mini", systemPrompt = "You are helpful")
val reply1 = chat.send("Hello!")
val reply2 = chat.send("Tell me a joke")

final openai = ProtectMyAPIAI.openAIService();
 
// Simple chat
final response = await openai.chat(
    message: "Explain machine learning",
    model: "gpt-4o-mini",
    systemPrompt: "You are a teacher",
);
 
// Multi-turn conversation
final chat = openai.chatSession(model: "gpt-4o-mini", systemPrompt: "You are helpful");
final reply1 = await chat.send("Hello!");
final reply2 = await chat.send("Tell me a joke");

let openai = ProtectMyAPI.openAIService()
 
let result = try await openai.generateImage(
    prompt: "A futuristic city at sunset",
    model: "dall-e-3",
    size: .square1024,
    quality: .hd
)
 
if let url = result.data.first?.url {
    print("Image URL: \(url)")
}

val openai = ProtectMyAPIAI.openAIService()
 
val result = openai.generateImage(
    prompt = "A futuristic city at sunset",
    model = "dall-e-3",
    size = OpenAIImageSize.SQUARE_1024,
    quality = OpenAIImageQuality.HD
)
 
result.data.firstOrNull()?.url?.let { url ->
    println("Image URL: $url")
}

final openai = ProtectMyAPIAI.openAIService();
 
final result = await openai.generateImage(
    prompt: "A futuristic city at sunset",
    model: "dall-e-3",
    size: OpenAIImageSize.square1024,
    quality: OpenAIImageQuality.hd,
);
 
final url = result.data.firstOrNull?.url;
if (url != null) {
    print("Image URL: $url");
}

let anthropic = ProtectMyAPI.anthropicService()
 
// Simple message
let response = try await anthropic.chat(
    message: "What are the benefits of functional programming?",
    model: "claude-3-5-sonnet-20241022",
    systemPrompt: "You are a programming expert"
)
 
// Multi-turn conversation
let chat = anthropic.chatSession(
    model: "claude-3-5-sonnet-20241022",
    systemPrompt: "You are a helpful assistant"
)
let reply = try await chat.send("Hello Claude!")

val anthropic = ProtectMyAPIAI.anthropicService()
 
// Simple message
val response = anthropic.chat(
    message = "What are the benefits of functional programming?",
    model = "claude-3-5-sonnet-20241022",
    systemPrompt = "You are a programming expert"
)
 
// Multi-turn conversation
val chat = anthropic.chatSession(
    model = "claude-3-5-sonnet-20241022",
    systemPrompt = "You are a helpful assistant"
)
val reply = chat.send("Hello Claude!")

final anthropic = ProtectMyAPIAI.anthropicService();
 
// Simple message
final response = await anthropic.chat(
    message: "What are the benefits of functional programming?",
    model: "claude-3-5-sonnet-20241022",
    systemPrompt: "You are a programming expert",
);
 
// Multi-turn conversation
final chat = anthropic.chatSession(
    model: "claude-3-5-sonnet-20241022",
    systemPrompt: "You are a helpful assistant",
);
final reply = await chat.send("Hello Claude!");

// Gemini streaming
let gemini = ProtectMyAPI.geminiService()
for try await text in gemini.streamText(prompt: "Tell me a story") {
    print(text, terminator: "")
}
 
// OpenAI streaming
let openai = ProtectMyAPI.openAIService()
for try await text in openai.streamChat(message: "Tell me a story") {
    print(text, terminator: "")
}
 
// Anthropic streaming
let anthropic = ProtectMyAPI.anthropicService()
for try await text in anthropic.streamChat(message: "Tell me a story") {
    print(text, terminator: "")
}
 
// Streaming with tool support
let request = OpenAIChatRequest(model: "gpt-4o", messages: messages, tools: tools)
for try await text in openai.streamChatWithTools(body: request) { name, args in
    let result = await executeFunction(name, args)
    print("Tool \(name) returned: \(result)")
} {
    print(text, terminator: "")
}

// Gemini streaming
val gemini = ProtectMyAPIAI.geminiService()
gemini.streamText(prompt = "Tell me a story").collect { text ->
    print(text)
}
 
// OpenAI streaming
val openai = ProtectMyAPIAI.openAIService()
openai.streamChat(message = "Tell me a story").collect { text ->
    print(text)
}
 
// Anthropic streaming
val anthropic = ProtectMyAPIAI.anthropicService()
anthropic.streamChat(message = "Tell me a story").collect { text ->
    print(text)
}

// Gemini streaming
final gemini = ProtectMyAPIAI.geminiService();
await for (final text in gemini.streamText(prompt: "Tell me a story")) {
    stdout.write(text);
}
 
// OpenAI streaming
final openai = ProtectMyAPIAI.openAIService();
await for (final text in openai.streamChat(message: "Tell me a story")) {
    stdout.write(text);
}
 
// Anthropic streaming
final anthropic = ProtectMyAPIAI.anthropicService();
await for (final text in anthropic.streamChat(message: "Tell me a story")) {
    stdout.write(text);
}

// Create a streaming session
let session = anthropic.streamingChatSession(
    model: "claude-3-5-sonnet-20241022",
    systemPrompt: "You are a helpful assistant"
)
 
// Stream each response
for try await text in session.send("Hello!") {
    print(text, terminator: "")
}
print()
 
// Continue the conversation
for try await text in session.send("Tell me more") {
    print(text, terminator: "")
}

val session = anthropic.streamingChatSession(
    model = "claude-3-5-sonnet-20241022",
    systemPrompt = "You are a helpful assistant"
)
 
session.send("Hello!").collect { print(it) }
session.send("Tell me more").collect { print(it) }

final session = anthropic.streamingChatSession(
    model: "claude-3-5-sonnet-20241022",
    systemPrompt: "You are a helpful assistant",
);
 
await for (final text in session.send("Hello!")) {
    stdout.write(text);
}

let gemini = ProtectMyAPI.geminiService()
 
// Search grounded response
let response = try await gemini.searchGrounded(
    prompt: "What are the latest AI developments?",
    model: "gemini-2.0-flash"
)
 
print(response.text)
 
// Access sources
if let metadata = response.groundingMetadata {
    for chunk in metadata.groundingChunks {
        print("Source: \(chunk.title ?? "") - \(chunk.uri ?? "")")
    }
}
 
// Stream search grounded content
for try await text in gemini.streamSearchGrounded(prompt: "Latest tech news") {
    print(text, terminator: "")
}

val gemini = ProtectMyAPIAI.geminiService()
 
val response = gemini.searchGrounded(
    prompt = "What are the latest AI developments?",
    model = "gemini-2.0-flash"
)
 
println(response.text)
 
// Access sources
response.groundingMetadata?.groundingChunks?.forEach { chunk ->
    println("Source: ${chunk.title} - ${chunk.uri}")
}

final gemini = ProtectMyAPIAI.geminiService();
 
final response = await gemini.searchGrounded(
    prompt: "What are the latest AI developments?",
    model: "gemini-2.0-flash",
);
 
print(response.text);
 
// Access sources
response.groundingMetadata?.groundingChunks.forEach((chunk) {
    print("Source: ${chunk.title} - ${chunk.uri}");
});

let openai = ProtectMyAPI.openAIService()
 
let result = try await openai.webSearch(
    query: "Latest news about Apple Vision Pro",
    model: "gpt-4o",
    searchOptions: OpenAIWebSearchOptions(
        searchContextSize: "medium",
        userLocation: OpenAIUserLocation(
            type: "approximate",
            country: "US"
        )
    )
)
print(result)

val openai = ProtectMyAPIAI.openAIService()
 
val result = openai.webSearch(
    query = "Latest news about Apple Vision Pro",
    model = "gpt-4o",
    searchOptions = OpenAIWebSearchOptions(
        searchContextSize = "medium",
        userLocation = OpenAIUserLocation(country = "US")
    )
)
println(result)

final openai = ProtectMyAPIAI.openAIService();
 
final result = await openai.webSearch(
    query: "Latest news about Apple Vision Pro",
    model: "gpt-4o",
    searchOptions: OpenAIWebSearchOptions(
        searchContextSize: "medium",
        userLocation: OpenAIUserLocation(country: "US"),
    ),
);
print(result);

let openai = ProtectMyAPI.openAIService()
 
// Text moderation
let result = try await openai.moderateText("Check this content...")
 
if result.flagged {
    print("Content flagged!")
    for (category, flagged) in result.categories where flagged {
        print("  - \(category): \(result.scores[category] ?? 0)")
    }
}
 
// Image moderation
let imageResult = try await openai.moderateImage("https://example.com/image.jpg")

val openai = ProtectMyAPIAI.openAIService()
 
val result = openai.moderateText("Check this content...")
 
if (result.flagged) {
    println("Content flagged!")
    result.categories.filter { it.value }.forEach { (category, _) ->
        println("  - $category: ${result.scores[category]}")
    }
}

final openai = ProtectMyAPIAI.openAIService();
 
final result = await openai.moderateText("Check this content...");
 
if (result.flagged) {
    print("Content flagged!");
    result.categories.forEach((category, flagged) {
        if (flagged) print("  - $category: ${result.scores[category]}");
    });
}

let openai = ProtectMyAPI.openAIService()
 
let editedImages = try await openai.editImage(
    prompt: "Add a rainbow to the sky",
    imageData: originalImageData,
    maskData: maskData, // Optional: define area to edit
    model: "gpt-image-1",
    n: 1,
    size: "1024x1024",
    quality: "hd"
)
 
for url in editedImages {
    print("Edited image: \(url)")
}

val openai = ProtectMyAPIAI.openAIService()
 
val editedImages = openai.editImage(
    prompt = "Add a rainbow to the sky",
    imageData = originalImageData,
    maskData = maskData,
    model = "gpt-image-1",
    n = 1,
    size = "1024x1024",
    quality = "hd"
)
 
editedImages.forEach { url -> println("Edited image: $url") }

final openai = ProtectMyAPIAI.openAIService();
 
final editedImages = await openai.editImage(
    prompt: "Add a rainbow to the sky",
    imageData: originalImageData,
    maskData: maskData,
    model: "gpt-image-1",
    n: 1,
    size: "1024x1024",
    quality: "hd",
);
 
for (final url in editedImages) {
    print("Edited image: $url");
}

let gemini = ProtectMyAPI.geminiService()
 
// Upload a video
let uploadedFile = try await gemini.uploadVideo(
    data: videoData,
    mimeType: "video/mp4",
    displayName: "my-video.mp4"
)
 
// Wait for processing
let readyFile = try await gemini.waitForFileProcessing(
    name: uploadedFile.name,
    timeout: 300
)
 
// Analyze the video
let analysis = try await gemini.analyzeVideo(
    fileUri: readyFile.uri!,
    prompt: "Describe what happens in this video"
)
print(analysis)
 
// Clean up
try await gemini.deleteFile(name: readyFile.name)

val gemini = ProtectMyAPIAI.geminiService()
 
val uploadedFile = gemini.uploadVideo(
    data = videoData,
    mimeType = "video/mp4",
    displayName = "my-video.mp4"
)
 
val readyFile = gemini.waitForFileProcessing(
    name = uploadedFile.name,
    timeout = 300_000
)
 
val analysis = gemini.analyzeVideo(
    fileUri = readyFile.uri!!,
    prompt = "Describe what happens in this video"
)
println(analysis)

final gemini = ProtectMyAPIAI.geminiService();
 
final uploadedFile = await gemini.uploadVideo(
    data: videoData,
    mimeType: "video/mp4",
    displayName: "my-video.mp4",
);
 
final readyFile = await gemini.waitForFileProcessing(
    uploadedFile.name,
    timeout: Duration(minutes: 5),
);
 
final analysis = await gemini.analyzeVideo(
    fileUri: readyFile.uri!,
    prompt: "Describe what happens in this video",
);
print(analysis);

let gemini = ProtectMyAPI.geminiService()
 
let images = try await gemini.generateImageWithImagen(
    prompt: "A serene Japanese garden at sunrise",
    model: "imagen-3.0-generate-002",
    numberOfImages: 2,
    aspectRatio: "16:9",
    negativePrompt: "blurry, low quality"
)
 
for imageData in images {
    let image = UIImage(data: imageData)
    // Display image
}
 
// Edit images with Imagen
let editedImages = try await gemini.editImageWithImagen(
    prompt: "Remove the background",
    imageData: originalImageData,
    editMode: .inpaintRemove
)

val gemini = ProtectMyAPIAI.geminiService()
 
val images = gemini.generateImageWithImagen(
    prompt = "A serene Japanese garden at sunrise",
    model = "imagen-3.0-generate-002",
    numberOfImages = 2,
    aspectRatio = "16:9",
    negativePrompt = "blurry, low quality"
)
 
images.forEach { imageData ->
    val bitmap = BitmapFactory.decodeByteArray(imageData, 0, imageData.size)
}

final gemini = ProtectMyAPIAI.geminiService();
 
final images = await gemini.generateImageWithImagen(
    prompt: "A serene Japanese garden at sunrise",
    model: "imagen-3.0-generate-002",
    numberOfImages: 2,
    aspectRatio: "16:9",
    negativePrompt: "blurry, low quality",
);
 
for (final imageData in images) {
    final image = Image.memory(imageData);
}

let anthropic = ProtectMyAPI.anthropicService()
 
// Load PDF
let pdfURL = Bundle.main.url(forResource: "document", withExtension: "pdf")!
let pdfData = try Data(contentsOf: pdfURL)
 
// Analyze PDF
let analysis = try await anthropic.analyzePDF(
    prompt: "Summarize the key points of this document",
    pdfData: pdfData,
    model: "claude-3-5-sonnet-20241022",
    maxTokens: 4096
)
print(analysis)
 
// Stream PDF analysis
for try await text in anthropic.streamAnalyzePDF(
    prompt: "Extract all dates and deadlines",
    pdfData: pdfData
) {
    print(text, terminator: "")
}

val anthropic = ProtectMyAPIAI.anthropicService()
 
val pdfData = loadPDFFile()
 
val analysis = anthropic.analyzePDF(
    prompt = "Summarize the key points",
    pdfData = pdfData,
    model = "claude-3-5-sonnet-20241022"
)
println(analysis)

final anthropic = ProtectMyAPIAI.anthropicService();
 
final pdfData = await loadPDFFile();
 
final analysis = await anthropic.analyzePDF(
    prompt: "Summarize the key points",
    pdfData: pdfData,
    model: "claude-3-5-sonnet-20241022",
);
print(analysis);

let anthropic = ProtectMyAPI.anthropicService()
 
// Long system prompt (e.g., documentation, code context)
let systemPrompt = """
You are an expert in the following codebase...
[Large context here - 1000+ tokens benefit from caching]
"""
 
// Multiple requests reuse the cached system prompt
let response1 = try await anthropic.chatWithCachedSystem(
    message: "How do I add a new feature?",
    systemPrompt: systemPrompt,
    cacheTTL: .fiveMinutes
)
 
let response2 = try await anthropic.chatWithCachedSystem(
    message: "What tests should I write?",
    systemPrompt: systemPrompt,
    cacheTTL: .fiveMinutes
)

val anthropic = ProtectMyAPIAI.anthropicService()
 
val response = anthropic.chatWithCachedSystem(
    message = "How do I add a new feature?",
    systemPrompt = longSystemPrompt,
    cacheTTL = AnthropicCacheTTL.FIVE_MINUTES
)

final anthropic = ProtectMyAPIAI.anthropicService();
 
final response = await anthropic.chatWithCachedSystem(
    message: "How do I add a new feature?",
    systemPrompt: longSystemPrompt,
    cacheTTL: AnthropicCacheTTL.fiveMinutes,
);

let openai = ProtectMyAPI.openAIService()
 
// Upload a file
let file = try await openai.uploadFile(
    data: documentData,
    filename: "knowledge-base.txt",
    purpose: "assistants"
)
 
// Create a vector store
let vectorStore = try await openai.createVectorStore(
    name: "My Knowledge Base",
    fileIds: [file.id],
    metadata: ["category": "documentation"]
)
 
// Add more files
let newFile = try await openai.addFileToVectorStore(
    vectorStoreId: vectorStore.id,
    fileId: anotherFile.id
)
 
// List files
let files = try await openai.listFiles(purpose: "assistants")
 
// Clean up
try await openai.deleteVectorStore(vectorStoreId: vectorStore.id)
try await openai.deleteFile(fileId: file.id)

val openai = ProtectMyAPIAI.openAIService()
 
val file = openai.uploadFile(
    data = documentData,
    filename = "knowledge-base.txt",
    purpose = "assistants"
)
 
val vectorStore = openai.createVectorStore(
    name = "My Knowledge Base",
    fileIds = listOf(file.id)
)

final openai = ProtectMyAPIAI.openAIService();
 
final file = await openai.uploadFile(
    data: documentData,
    filename: "knowledge-base.txt",
    purpose: "assistants",
);
 
final vectorStore = await openai.createVectorStore(
    name: "My Knowledge Base",
    fileIds: [file.id],
);

let openai = ProtectMyAPI.openAIService()
 
// Create a response with web search
let response = try await openai.createResponse(
    input: "What's happening in AI today?",
    model: "gpt-4o",
    tools: [
        .webSearch(),
        .codeInterpreter()
    ],
    instructions: "Be concise and factual"
)
 
print(response.textContent)
 
// Stream a response
for try await event in openai.streamResponse(
    input: "Analyze this data and create a chart",
    tools: [.codeInterpreter()]
) {
    switch event.type {
    case "response.output_text.delta":
        print(event.data["delta"] ?? "", terminator: "")
    default:
        break
    }
}

val openai = ProtectMyAPIAI.openAIService()
 
val response = openai.createResponse(
    input = "What's happening in AI today?",
    model = "gpt-4o",
    tools = listOf(
        OpenAIResponsesTool.webSearch(),
        OpenAIResponsesTool.codeInterpreter()
    )
)
 
println(response.textContent)

final openai = ProtectMyAPIAI.openAIService();
 
final response = await openai.createResponse(
    input: "What's happening in AI today?",
    model: "gpt-4o",
    tools: [
        OpenAIResponsesTool.webSearch(),
        OpenAIResponsesTool.codeInterpreter(),
    ],
);
 
print(response.textContent);

let openai = ProtectMyAPI.openAIService()
 
let config = try await openai.realtimeSessionConfig(
    model: "gpt-4o-realtime-preview",
    modalities: ["text", "audio"],
    voice: "alloy",
    instructions: "You are a friendly assistant"
)
 
// Use config.webSocketUrl and config.clientSecret 
// to establish a WebSocket connection
print("WebSocket URL: \(config.webSocketUrl)")
print("Token expires at: \(config.expiresAt)")

val openai = ProtectMyAPIAI.openAIService()
 
val config = openai.realtimeSessionConfig(
    model = "gpt-4o-realtime-preview",
    modalities = listOf("text", "audio"),
    voice = "alloy"
)
 
println("WebSocket URL: ${config.webSocketUrl}")

final openai = ProtectMyAPIAI.openAIService();
 
final config = await openai.realtimeSessionConfig(
    model: "gpt-4o-realtime-preview",
    modalities: ["text", "audio"],
    voice: "alloy",
);
 
print("WebSocket URL: ${config.webSocketUrl}");

let gemini = ProtectMyAPI.geminiService()
 
let result = try await gemini.generateWithCodeExecution(
    prompt: "Calculate the fibonacci sequence up to 100 and plot it",
    model: "gemini-2.0-flash"
)
 
print("Response: \(result.text)")
 
for code in result.executedCode {
    print("Language: \(code.language)")
    print("Code: \(code.code)")
    print("Output: \(code.output ?? "No output")")
}

val gemini = ProtectMyAPIAI.geminiService()
 
val result = gemini.generateWithCodeExecution(
    prompt = "Calculate the fibonacci sequence up to 100",
    model = "gemini-2.0-flash"
)
 
println(result.text)
result.executedCode.forEach { code ->
    println("Output: ${code.output}")
}

final gemini = ProtectMyAPIAI.geminiService();
 
final result = await gemini.generateWithCodeExecution(
    prompt: "Calculate the fibonacci sequence up to 100",
    model: "gemini-2.0-flash",
);
 
print(result.text);
for (final code in result.executedCode) {
    print("Output: ${code.output}");
}

let deepseek = ProtectMyAPI.deepSeekService()
 
// Simple chat
let response = try await deepseek.chat(
    message: "Explain machine learning",
    model: .chat,
    systemPrompt: "You are a helpful assistant"
)
print(response)
 
// Streaming
for try await chunk in deepseek.streamChat(message: "Write a story") {
    print(chunk, terminator: "")
}

val deepseek = ProtectMyAPIAI.deepSeekService()
 
// Simple chat
val response = deepseek.chat(
    message = "Explain machine learning",
    model = DeepSeekModel.CHAT,
    systemPrompt = "You are a helpful assistant"
)
println(response)
 
// Streaming
deepseek.streamChat(message = "Write a story").collect { chunk ->
    print(chunk)
}

final deepseek = ProtectMyAPIAI.deepSeekService();
 
// Simple chat
final response = await deepseek.chat(
    message: "Explain machine learning",
    model: DeepSeekModel.chat,
    systemPrompt: "You are a helpful assistant",
);
print(response);
 
// Streaming
await for (final chunk in deepseek.streamChat(message: "Write a story")) {
    stdout.write(chunk);
}

let deepseek = ProtectMyAPI.deepSeekService()
 
// Get reasoning with chain-of-thought
let result = try await deepseek.reason(
    message: "Solve: If 3x + 5 = 20, what is x?",
    systemPrompt: "Show your work step by step"
)
 
print("Answer: \(result.content)")
if let reasoning = result.reasoningContent {
    print("Reasoning: \(reasoning)")
}
 
// Track reasoning tokens
if let details = result.usage?.completionTokensDetails {
    print("Reasoning tokens: \(details.reasoningTokens ?? 0)")
}
 
// Stream reasoning
for try await chunk in deepseek.streamReason(message: "Explain quantum entanglement") {
    if let reasoning = chunk.reasoningContent {
        print("[Reasoning] \(reasoning)", terminator: "")
    }
    if let content = chunk.content {
        print(content, terminator: "")
    }
}

val deepseek = ProtectMyAPIAI.deepSeekService()
 
// Get reasoning with chain-of-thought
val result = deepseek.reason(
    message = "Solve: If 3x + 5 = 20, what is x?",
    systemPrompt = "Show your work step by step"
)
 
println("Answer: ${result.content}")
result.reasoningContent?.let { println("Reasoning: $it") }
 
// Stream reasoning
deepseek.streamReason(message = "Explain quantum entanglement").collect { chunk ->
    chunk.reasoningContent?.let { print("[Reasoning] $it") }
    chunk.content?.let { print(it) }
}

final deepseek = ProtectMyAPIAI.deepSeekService();
 
// Get reasoning with chain-of-thought
final result = await deepseek.reason(
    message: "Solve: If 3x + 5 = 20, what is x?",
    systemPrompt: "Show your work step by step",
);
 
print("Answer: ${result.content}");
if (result.reasoningContent != null) {
    print("Reasoning: ${result.reasoningContent}");
}
 
// Stream reasoning
await for (final chunk in deepseek.streamReason(message: "Explain quantum entanglement")) {
    if (chunk.reasoningContent != null) {
        stdout.write("[Reasoning] ${chunk.reasoningContent}");
    }
    if (chunk.content != null) {
        stdout.write(chunk.content);
    }
}

let deepseek = ProtectMyAPI.deepSeekService()
 
// Create a session
let session = deepseek.chatSession(
    model: .chat,
    systemPrompt: "You are a math tutor"
)
 
let response1 = try await session.send("What is calculus?")
let response2 = try await session.send("Can you give me an example?")
 
// Streaming session
let streamingSession = deepseek.streamingChatSession(
    model: .chat,
    systemPrompt: "You are creative"
)
 
for try await chunk in streamingSession.send("Tell me a joke") {
    print(chunk, terminator: "")
}

val deepseek = ProtectMyAPIAI.deepSeekService()
 
// Create a session
val session = deepseek.chatSession(
    model = DeepSeekModel.CHAT,
    systemPrompt = "You are a math tutor"
)
 
val response1 = session.send("What is calculus?")
val response2 = session.send("Can you give me an example?")
 
// Streaming session
val streamingSession = deepseek.streamingChatSession()
streamingSession.send("Tell me a joke").collect { print(it) }

final deepseek = ProtectMyAPIAI.deepSeekService();
 
// Create a session
final session = deepseek.chatSession(
    model: DeepSeekModel.chat,
    systemPrompt: "You are a math tutor",
);
 
final response1 = await session.send("What is calculus?");
final response2 = await session.send("Can you give me an example?");
 
// Streaming session
final streamingSession = deepseek.streamingChatSession();
await for (final chunk in streamingSession.send("Tell me a joke")) {
    stdout.write(chunk);
}

let brave = ProtectMyAPI.braveSearchService()
 
// Simple web search
let results = try await brave.webSearch(
    query: "Swift programming language",
    count: 10,
    safesearch: .moderate
)
 
for result in results.web {
    print("\(result.title): \(result.url)")
    print(result.description ?? "")
}
 
// With AI summary
let searchWithSummary = try await brave.webSearch(
    query: "Latest tech news",
    summary: true
)
 
if let summary = searchWithSummary.summary?.summary {
    print("Summary: \(summary)")
}

val brave = ProtectMyAPIAI.braveSearchService()
 
// Simple web search
val results = brave.webSearch(
    query = "Kotlin programming language",
    count = 10,
    safesearch = BraveSafesearch.MODERATE
)
 
results.web.forEach { result ->
    println("${result.title}: ${result.url}")
}
 
// With AI summary
val searchWithSummary = brave.webSearch(
    query = "Latest tech news",
    summary = true
)
 
searchWithSummary.summary?.summary?.let { println("Summary: $it") }

final brave = ProtectMyAPIAI.braveSearchService();
 
// Simple web search
final results = await brave.webSearch(
    query: "Flutter programming",
    count: 10,
    safesearch: BraveSafesearch.moderate,
);
 
for (final result in results.web) {
    print("${result.title}: ${result.url}");
}
 
// With AI summary
final searchWithSummary = await brave.webSearch(
    query: "Latest tech news",
    summary: true,
);
 
if (searchWithSummary.summary?.summary != null) {
    print("Summary: ${searchWithSummary.summary!.summary}");
}

let brave = ProtectMyAPI.braveSearchService()
 
let news = try await brave.newsSearch(
    query: "technology",
    freshness: .pastDay,
    count: 20
)
 
for article in news.results {
    print("\(article.title) - \(article.age ?? "")")
    print("Source: \(article.source ?? "Unknown")")
}

val brave = ProtectMyAPIAI.braveSearchService()
 
val news = brave.newsSearch(
    query = "technology",
    freshness = BraveFreshness.PAST_DAY,
    count = 20
)
 
news.results.forEach { article ->
    println("${article.title} - ${article.age}")
}

final brave = ProtectMyAPIAI.braveSearchService();
 
final news = await brave.newsSearch(
    query: "technology",
    freshness: BraveFreshness.pastDay,
    count: 20,
);
 
for (final article in news.results) {
    print("${article.title} - ${article.age}");
}

let brave = ProtectMyAPI.braveSearchService()
 
// Image search
let images = try await brave.imageSearch(
    query: "nature photography",
    safesearch: .strict
)
 
for image in images.results {
    print("\(image.title): \(image.url)")
    print("Size: \(image.properties?.width ?? 0)x\(image.properties?.height ?? 0)")
}
 
// Video search
let videos = try await brave.videoSearch(
    query: "Swift tutorials",
    freshness: .pastMonth
)
 
for video in videos.results {
    print("\(video.title) - \(video.duration ?? "")")
    print("Views: \(video.views ?? 0)")
}

val brave = ProtectMyAPIAI.braveSearchService()
 
// Image search
val images = brave.imageSearch(
    query = "nature photography",
    safesearch = BraveSafesearch.STRICT
)
 
images.results.forEach { image ->
    println("${image.title}: ${image.url}")
}
 
// Video search
val videos = brave.videoSearch(
    query = "Kotlin tutorials",
    freshness = BraveFreshness.PAST_MONTH
)
 
videos.results.forEach { video ->
    println("${video.title} - ${video.duration}")
}

final brave = ProtectMyAPIAI.braveSearchService();
 
// Image search
final images = await brave.imageSearch(
    query: "nature photography",
    safesearch: BraveSafesearch.strict,
);
 
for (final image in images.results) {
    print("${image.title}: ${image.url}");
}
 
// Video search
final videos = await brave.videoSearch(
    query: "Flutter tutorials",
    freshness: BraveFreshness.pastMonth,
);
 
for (final video in videos.results) {
    print("${video.title} - ${video.duration}");
}

let brave = ProtectMyAPI.braveSearchService()
 
let places = try await brave.localSearch(
    query: "coffee shops near Times Square",
    count: 10
)
 
for place in places.results {
    print("\(place.title)")
    print("Address: \(place.address ?? "N/A")")
    print("Rating: \(place.rating?.ratingValue ?? 0)/\(place.rating?.bestRating ?? 5)")
    print("Phone: \(place.phone ?? "N/A")")
}

val brave = ProtectMyAPIAI.braveSearchService()
 
val places = brave.localSearch(
    query = "coffee shops near Times Square",
    count = 10
)
 
places.results.forEach { place ->
    println(place.title)
    println("Address: ${place.address}")
    println("Rating: ${place.rating?.ratingValue}/${place.rating?.bestRating}")
}

final brave = ProtectMyAPIAI.braveSearchService();
 
final places = await brave.localSearch(
    query: "coffee shops near Times Square",
    count: 10,
);
 
for (final place in places.results) {
    print(place.title);
    print("Address: ${place.address}");
    print("Rating: ${place.rating?.ratingValue}/${place.rating?.bestRating}");
}

let brave = ProtectMyAPI.braveSearchService()
 
let suggestions = try await brave.suggest(
    query: "how to",
    rich: true
)
 
for suggestion in suggestions.suggestions {
    print(suggestion.query)
    if suggestion.isEntity == true {
        print("  Title: \(suggestion.title ?? "")")
    }
}

val brave = ProtectMyAPIAI.braveSearchService()
 
val suggestions = brave.suggest(
    query = "how to",
    rich = true
)
 
suggestions.suggestions.forEach { suggestion ->
    println(suggestion.query)
}

final brave = ProtectMyAPIAI.braveSearchService();
 
final suggestions = await brave.suggest(
    query: "how to",
    rich: true,
);
 
for (final suggestion in suggestions.suggestions) {
    print(suggestion.query);
}

let deepl = ProtectMyAPI.deepLService()
 
// Simple translation
let translated = try await deepl.translateText(
    text: "Hello, how are you?",
    targetLang: .german,
    formality: .more
)
print(translated) // "Hallo, wie geht es Ihnen?"
 
// Batch translation
let response = try await deepl.translate(
    text: ["Hello", "Goodbye", "Thank you"],
    targetLang: .spanish
)
 
for translation in response.translations {
    print("\(translation.text) (detected: \(translation.detectedSourceLanguage ?? "unknown"))")
}

val deepl = ProtectMyAPIAI.deepLService()
 
// Simple translation
val translated = deepl.translateText(
    text = "Hello, how are you?",
    targetLang = DeepLLanguage.GERMAN,
    formality = DeepLFormality.MORE
)
println(translated) // "Hallo, wie geht es Ihnen?"
 
// Batch translation
val response = deepl.translate(
    text = listOf("Hello", "Goodbye", "Thank you"),
    targetLang = DeepLLanguage.SPANISH
)
 
response.translations.forEach { translation ->
    println("${translation.text} (detected: ${translation.detectedSourceLanguage})")
}

final deepl = ProtectMyAPIAI.deepLService();
 
// Simple translation
final translated = await deepl.translateText(
    text: "Hello, how are you?",
    targetLang: DeepLLanguage.german,
    formality: DeepLFormality.more,
);
print(translated); // "Hallo, wie geht es Ihnen?"
 
// Batch translation
final response = await deepl.translate(
    text: ["Hello", "Goodbye", "Thank you"],
    targetLang: DeepLLanguage.spanish,
);
 
for (final translation in response.translations) {
    print("${translation.text} (detected: ${translation.detectedSourceLanguage})");
}