feat(examples): add Rust examples 11-19 and fix CI/CD issues

Add comprehensive examples demonstrating advanced LLMKit features:
- 11_embeddings: Text embedding generation with multiple providers
- 12_audio_synthesis: Text-to-speech with OpenAI TTS
- 13_audio_transcription: Speech-to-text with Whisper
- 14_image_generation: Image generation with DALL-E and Stable Diffusion
- 15_specialized_api: Ranking, moderation, and classification
- 16_video_generation: Video generation with RunwayML
- 17_response_caching: Cache configuration demonstration
- 18_retry_resilience: Retry configuration and error handling
- 19_openai_compatible: Generic OpenAI-compatible provider setup

Also fixes:
- Add feature gates for Anthropic-specific integration tests
- Export missing Python binding types (audio, video, image, specialized)
- Fix Node.js unit test expectations for model info and capabilities
- Add try/catch for Vertex/Bedrock tests when features unavailable

Author: yfedoseev

Cargo.toml

@@ -564,5 +564,38 @@ required-features = ["openrouter"]
 name = "10_batch_processing"
 required-features = ["openrouter"]
 
-# Examples 11-19 are available in Python and TypeScript.
-# Rust implementations will be added as the APIs become available.
+[[example]]
+name = "11_embeddings"
+required-features = ["openai"]
+
+[[example]]
+name = "12_audio_synthesis"
+required-features = ["openai"]
+
+[[example]]
+name = "13_audio_transcription"
+required-features = ["openai"]
+
+[[example]]
+name = "14_image_generation"
+required-features = ["openai"]
+
+[[example]]
+name = "15_specialized_api"
+required-features = ["cohere", "openai"]
+
+[[example]]
+name = "16_video_generation"
+required-features = ["runwayml"]
+
+[[example]]
+name = "17_response_caching"
+required-features = ["openrouter"]
+
+[[example]]
+name = "18_retry_resilience"
+required-features = ["openrouter"]
+
+[[example]]
+name = "19_openai_compatible"
+required-features = ["openai-compatible"]

examples/11_embeddings.rs

@@ -0,0 +1,141 @@
+//! Embeddings Example
+//!
+//! Demonstrates text embedding generation and similarity computation.
+//!
+//! Requirements:
+//! - Set OPENAI_API_KEY environment variable (for text-embedding-3-small)
+//!
+//! Run:
+//!     cargo run --example 11_embeddings
+
+use llmkit::{EmbeddingRequest, LLMKitClient};
+
+#[tokio::main]
+async fn main() -> llmkit::Result<()> {
+    let client = LLMKitClient::builder()
+        .with_openai_from_env()
+        .build()
+        .await?;
+
+    // Example 1: Basic embedding
+    println!("=== Example 1: Basic Embedding ===");
+    let request = EmbeddingRequest::new("openai/text-embedding-3-small", "Hello, world!");
+    let response = client.embed(request).await?;
+
+    println!("Model: {}", response.model);
+    println!("Dimensions: {}", response.dimensions());
+    if let Some(values) = response.values() {
+        println!("First 5 values: {:?}", &values[..5.min(values.len())]);
+    }
+    println!("Tokens used: {}", response.usage.total_tokens);
+
+    // Example 2: Batch embeddings
+    println!("\n=== Example 2: Batch Embeddings ===");
+    let texts = vec![
+        "The quick brown fox",
+        "A lazy dog sleeps",
+        "Python is a programming language",
+        "Machine learning is fascinating",
+    ];
+
+    let request = EmbeddingRequest::batch("openai/text-embedding-3-small", texts.clone());
+    let response = client.embed(request).await?;
+
+    println!("Got {} embeddings", response.embeddings.len());
+    println!("Dimensions: {}", response.dimensions());
+    for emb in &response.embeddings {
+        println!("  Text {}: {} dimensions", emb.index, emb.values.len());
+    }
+
+    // Example 3: Compute similarity
+    println!("\n=== Example 3: Similarity Computation ===");
+    let similarity_texts = vec![
+        "I love programming in Python",
+        "Python coding is my favorite",
+        "The weather is nice today",
+        "I enjoy writing code",
+    ];
+
+    let request =
+        EmbeddingRequest::batch("openai/text-embedding-3-small", similarity_texts.clone());
+    let response = client.embed(request).await?;
+
+    let reference = &response.embeddings[0];
+    println!("Reference: '{}'", similarity_texts[0]);
+    println!("\nSimilarities:");
+
+    for (i, emb) in response.embeddings.iter().skip(1).enumerate() {
+        let similarity = reference.cosine_similarity(emb);
+        println!("  vs '{}': {:.4}", similarity_texts[i + 1], similarity);
+    }
+
+    // Example 4: Semantic search
+    println!("\n=== Example 4: Semantic Search ===");
+    let documents = vec![
+        "Python is a high-level programming language",
+        "Machine learning uses algorithms to learn from data",
+        "The Eiffel Tower is located in Paris, France",
+        "Deep learning is a subset of machine learning",
+        "JavaScript is commonly used for web development",
+        "Natural language processing deals with text and speech",
+    ];
+
+    let query = "What is artificial intelligence?";
+    println!("Query: '{}'", query);
+
+    // Embed query
+    let query_response = client
+        .embed(EmbeddingRequest::new(
+            "openai/text-embedding-3-small",
+            query,
+        ))
+        .await?;
+    let query_embedding = &query_response.embeddings[0];
+
+    // Embed documents
+    let doc_response = client
+        .embed(EmbeddingRequest::batch(
+            "openai/text-embedding-3-small",
+            documents.clone(),
+        ))
+        .await?;
+
+    // Compute similarities and rank
+    let mut results: Vec<(f32, &str)> = doc_response
+        .embeddings
+        .iter()
+        .enumerate()
+        .map(|(i, emb)| (query_embedding.cosine_similarity(emb), documents[i]))
+        .collect();
+
+    results.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap());
+
+    println!("\nResults (by relevance):");
+    for (similarity, doc) in results {
+        println!("  [{:.4}] {}", similarity, doc);
+    }
+
+    // Example 5: Distance metrics
+    println!("\n=== Example 5: Distance Metrics ===");
+    let metric_texts = vec!["Hello world", "Hello there"];
+
+    let response = client
+        .embed(EmbeddingRequest::batch(
+            "openai/text-embedding-3-small",
+            metric_texts.clone(),
+        ))
+        .await?;
+
+    let emb1 = &response.embeddings[0];
+    let emb2 = &response.embeddings[1];
+
+    println!("Text 1: '{}'", metric_texts[0]);
+    println!("Text 2: '{}'", metric_texts[1]);
+    println!();
+    println!("Distance metrics:");
+    println!("  Cosine similarity: {:.6}", emb1.cosine_similarity(emb2));
+    println!("  Dot product: {:.6}", emb1.dot_product(emb2));
+    println!("  Euclidean distance: {:.6}", emb1.euclidean_distance(emb2));
+
+    Ok(())
+}

examples/12_audio_synthesis.rs

@@ -0,0 +1,125 @@
+//! Audio Synthesis (Text-to-Speech) Example
+//!
+//! Demonstrates speech generation from text using various providers.
+//!
+//! Requirements:
+//! - Set OPENAI_API_KEY environment variable (for OpenAI TTS)
+//!   Or ELEVENLABS_API_KEY for ElevenLabs
+//!
+//! Run:
+//!     cargo run --example 12_audio_synthesis
+
+use llmkit::{AudioFormat, LLMKitClient, SpeechRequest};
+use std::path::Path;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let client = LLMKitClient::builder()
+        .with_openai_from_env()
+        .build()
+        .await?;
+
+    println!("=== Audio Synthesis Example ===\n");
+
+    // Example 1: Basic speech synthesis
+    println!("--- Example 1: Basic Speech Synthesis ---");
+    let text = "Hello! This is a demonstration of text-to-speech synthesis using LLMKit.";
+    println!("Input text: {}", text);
+
+    let request = SpeechRequest::new("openai/tts-1", text, "alloy");
+    let response = client.speech(request).await?;
+
+    let output_path = "output_basic.mp3";
+    response.save(output_path)?;
+    println!("Audio saved to: {}", output_path);
+    println!("Audio size: {} bytes", response.audio.len());
+    println!("Format: {:?}", response.format);
+
+    // Example 2: High-quality speech with different voice
+    println!("\n--- Example 2: High-Quality Speech ---");
+    let text = "This is high-quality audio synthesis with the 'nova' voice.";
+
+    let request = SpeechRequest::new("openai/tts-1-hd", text, "nova");
+    let response = client.speech(request).await?;
+
+    let output_path = "output_hd.mp3";
+    response.save(output_path)?;
+    println!("HD audio saved to: {}", output_path);
+    println!("Audio size: {} bytes", response.audio.len());
+
+    // Example 3: Different audio format
+    println!("\n--- Example 3: Different Audio Format ---");
+    let text = "Testing different audio formats.";
+
+    let request =
+        SpeechRequest::new("openai/tts-1", text, "shimmer").with_format(AudioFormat::Opus);
+    let response = client.speech(request).await?;
+
+    let output_path = "output_opus.opus";
+    response.save(output_path)?;
+    println!("Opus audio saved to: {}", output_path);
+    println!("Format: {:?}", response.format);
+
+    // Example 4: Adjusted speech speed
+    println!("\n--- Example 4: Adjusted Speech Speed ---");
+    let text = "This speech is generated at a faster pace.";
+
+    let request = SpeechRequest::new("openai/tts-1", text, "echo").with_speed(1.25);
+    let response = client.speech(request).await?;
+
+    let output_path = "output_fast.mp3";
+    response.save(output_path)?;
+    println!("Fast audio saved to: {}", output_path);
+
+    // Example 5: Slow speech
+    println!("\n--- Example 5: Slow Speech ---");
+    let text = "This speech is generated at a slower, more deliberate pace.";
+
+    let request = SpeechRequest::new("openai/tts-1", text, "fable").with_speed(0.8);
+    let response = client.speech(request).await?;
+
+    let output_path = "output_slow.mp3";
+    response.save(output_path)?;
+    println!("Slow audio saved to: {}", output_path);
+
+    // Example 6: Multiple voices comparison
+    println!("\n--- Example 6: Voice Comparison ---");
+    let voices = ["alloy", "echo", "fable", "onyx", "nova", "shimmer"];
+    let text = "The quick brown fox jumps over the lazy dog.";
+
+    for voice in voices {
+        let request = SpeechRequest::new("openai/tts-1", text, voice);
+        let response = client.speech(request).await?;
+
+        let output_path = format!("output_{}.mp3", voice);
+        response.save(&output_path)?;
+        println!("  Voice '{}': {} bytes", voice, response.audio.len());
+    }
+
+    // Clean up example files
+    println!("\n--- Cleanup ---");
+    let files_to_clean = [
+        "output_basic.mp3",
+        "output_hd.mp3",
+        "output_opus.opus",
+        "output_fast.mp3",
+        "output_slow.mp3",
+        "output_alloy.mp3",
+        "output_echo.mp3",
+        "output_fable.mp3",
+        "output_onyx.mp3",
+        "output_nova.mp3",
+        "output_shimmer.mp3",
+    ];
+
+    for file in &files_to_clean {
+        if Path::new(file).exists() {
+            std::fs::remove_file(file)?;
+            println!("Cleaned up: {}", file);
+        }
+    }
+
+    println!("\nAudio synthesis examples completed!");
+
+    Ok(())
+}