use siumai::prelude::*;
#[test]
fn test_common_params_structure() {
println!("🔍 Testing CommonParams structure and defaults");
let default_params = CommonParams::default();
println!(" Default model: '{}'", default_params.model);
println!(" Default temperature: {:?}", default_params.temperature);
println!(" Default max_tokens: {:?}", default_params.max_tokens);
println!(" Default top_p: {:?}", default_params.top_p);
println!(
" Default stop_sequences: {:?}",
default_params.stop_sequences
);
println!(" Default seed: {:?}", default_params.seed);
assert!(
default_params.model.is_empty(),
"Default model should be empty"
);
assert!(
default_params.temperature.is_none(),
"Default temperature should be None"
);
assert!(
default_params.max_tokens.is_none(),
"Default max_tokens should be None"
);
println!(" ✅ CommonParams defaults are correct");
}
#[test]
fn test_provider_specific_params() {
println!("\n🔍 Testing provider-specific parameters");
use siumai::params::{AnthropicParams, OpenAiParams};
let openai_params = OpenAiParams::default();
println!(
" OpenAI params created: {:?}",
openai_params.response_format
);
let anthropic_params = AnthropicParams::default();
println!(" Anthropic params created: {:?}", anthropic_params.system);
println!(" ✅ Provider-specific params are accessible");
}
#[tokio::test]
async fn test_parameter_integration() {
println!("\n🧪 Testing parameter integration with clients");
if let Ok(api_key) = std::env::var("OPENAI_API_KEY") {
let client = Provider::openai()
.api_key(&api_key)
.model("gpt-4o-mini")
.temperature(0.7)
.max_tokens(50)
.build()
.await;
match client {
Ok(_) => println!(" ✅ OpenAI client created with parameters"),
Err(e) => println!(" ⚠️ OpenAI client creation failed: {}", e),
}
} else {
println!(" ⏭️ Skipping OpenAI test (no API key)");
}
if let Ok(api_key) = std::env::var("XAI_API_KEY") {
let client = Provider::xai()
.api_key(&api_key)
.model("grok-3")
.temperature(0.8)
.max_tokens(30)
.build()
.await;
match client {
Ok(_) => println!(" ✅ xAI client created with parameters"),
Err(e) => println!(" ⚠️ xAI client creation failed: {}", e),
}
} else {
println!(" ⏭️ Skipping xAI test (no API key)");
}
if let Ok(api_key) = std::env::var("ANTHROPIC_API_KEY") {
let client = Provider::anthropic()
.api_key(&api_key)
.model("claude-3-5-haiku-20241022")
.temperature(0.9)
.max_tokens(40)
.build()
.await;
match client {
Ok(_) => println!(" ✅ Anthropic client created with parameters"),
Err(e) => println!(" ⚠️ Anthropic client creation failed: {}", e),
}
} else {
println!(" ⏭️ Skipping Anthropic test (no API key)");
}
println!(" ✅ Parameter integration test completed");
}
#[tokio::test]
async fn test_chat_capability_streaming_parameter_passing() {
println!("\n🔧 Testing ChatCapability STREAMING parameter passing");
if let Ok(api_key) = std::env::var("XAI_API_KEY") {
let client = Provider::xai()
.api_key(&api_key)
.model("grok-3")
.temperature(0.5)
.max_tokens(20)
.build()
.await
.expect("Failed to create xAI client");
println!(" ✅ xAI client created with specific parameters");
use siumai::traits::ChatCapability;
let capability: &dyn ChatCapability = &client;
let messages = vec![user!("Say 'test' in one word")];
match capability.chat_stream(messages, None).await {
Ok(mut stream) => {
use futures_util::StreamExt;
println!(" ✅ ChatCapability.chat_stream() works with parameters");
let mut content = String::new();
let mut count = 0;
while let Some(event) = stream.next().await {
match event {
Ok(ChatStreamEvent::ContentDelta { delta, .. }) => {
content.push_str(&delta);
count += 1;
if count >= 3 {
break;
}
}
Ok(ChatStreamEvent::StreamEnd { .. }) => break,
Err(e) => {
println!(" ⚠️ Stream error: {}", e);
break;
}
_ => {}
}
}
if !content.is_empty() {
println!(" Streaming response: {}", content.trim());
println!(
" ✅ Parameters correctly passed through ChatCapability (streaming)"
);
} else {
println!(
" ⚠️ No content received, but no model errors (parameters likely correct)"
);
}
}
Err(e) => {
if e.to_string().contains("model") || e.to_string().contains("404") {
println!(" ❌ Model error suggests parameter passing issue: {}", e);
println!(" ⚠️ This may indicate incompatibility with the provider");
} else {
println!(" ⚠️ Non-model error (likely API key issue): {}", e);
}
}
}
} else {
println!(" ⏭️ Skipping xAI ChatCapability streaming test (no API key)");
}
}
#[tokio::test]
async fn test_chat_capability_non_streaming_parameter_passing() {
println!("\n🔧 Testing ChatCapability NON-STREAMING parameter passing");
if let Ok(api_key) = std::env::var("XAI_API_KEY") {
let client = Provider::xai()
.api_key(&api_key)
.model("grok-3")
.temperature(0.5)
.max_tokens(20)
.build()
.await
.expect("Failed to create xAI client");
println!(" ✅ xAI client created with specific parameters");
use siumai::traits::ChatCapability;
let capability: &dyn ChatCapability = &client;
let messages = vec![user!("Say 'test' in one word")];
match capability.chat(messages).await {
Ok(response) => {
println!(" ✅ ChatCapability.chat() works with parameters");
let content_str = match &response.content {
siumai::types::MessageContent::Text(text) => text.as_str(),
_ => "[non-text content]",
};
println!(
" Non-streaming response: {}",
content_str.chars().take(50).collect::<String>()
);
println!(
" ✅ Parameters correctly passed through ChatCapability (non-streaming)"
);
}
Err(e) => {
if e.to_string().contains("model") || e.to_string().contains("404") {
println!(" ❌ Model error suggests parameter passing issue: {}", e);
println!(" ⚠️ This may indicate incompatibility with the provider");
} else {
println!(" ⚠️ Non-model error (likely API key issue): {}", e);
}
}
}
} else {
println!(" ⏭️ Skipping xAI ChatCapability non-streaming test (no API key)");
}
}
#[test]
fn test_parameter_architecture() {
println!("\n🏗️ Testing parameter architecture");
let common_params = CommonParams {
model: "test-model".to_string(),
temperature: Some(0.7),
max_tokens: Some(100),
top_p: Some(0.9),
stop_sequences: Some(vec!["STOP".to_string()]),
seed: Some(12345),
};
println!(" Common params structure:");
println!(" Model: {}", common_params.model);
println!(" Temperature: {:?}", common_params.temperature);
println!(" Max tokens: {:?}", common_params.max_tokens);
println!(" Top P: {:?}", common_params.top_p);
println!(" Stop sequences: {:?}", common_params.stop_sequences);
println!(" Seed: {:?}", common_params.seed);
use siumai::params::{AnthropicParams, OpenAiParams};
let openai_params = OpenAiParams {
response_format: None,
tool_choice: None,
parallel_tool_calls: Some(true),
store: Some(false),
..Default::default()
};
println!(" OpenAI-specific params:");
println!(" Response format: {:?}", openai_params.response_format);
println!(" Tool choice: {:?}", openai_params.tool_choice);
println!(
" Parallel tool calls: {:?}",
openai_params.parallel_tool_calls
);
println!(" Store: {:?}", openai_params.store);
let anthropic_params = AnthropicParams {
system: Some("You are a helpful assistant".to_string()),
..Default::default()
};
println!(" Anthropic-specific params:");
println!(" System: {:?}", anthropic_params.system);
println!(" ✅ Parameter architecture is well-structured");
println!(" 💡 Common params provide shared functionality");
println!(" 💡 Provider-specific params allow customization");
println!(" 💡 Both types work together in our fixed ChatCapability implementation");
}
#[test]
fn test_simple_verification() {
println!("🧪 Simple parameter verification test");
use siumai::types::CommonParams;
let params = CommonParams {
model: "test-model".to_string(),
temperature: Some(0.7),
max_tokens: Some(100),
top_p: Some(0.9),
stop_sequences: Some(vec!["STOP".to_string()]),
seed: Some(12345),
};
assert_eq!(params.model, "test-model");
assert_eq!(params.temperature, Some(0.7));
assert_eq!(params.max_tokens, Some(100));
println!(" ✅ CommonParams creation and access works");
use siumai::types::ProviderParams;
let provider_params = ProviderParams::openai()
.with_param("frequency_penalty", 0.1)
.with_param("presence_penalty", 0.2);
println!(" ✅ ProviderParams creation works");
let freq_penalty: Option<f64> = provider_params.get("frequency_penalty");
assert_eq!(freq_penalty, Some(0.1));
println!(" ✅ ProviderParams value retrieval works");
println!(" 🎯 Parameter handling is working correctly!");
}
#[tokio::test]
async fn test_comprehensive_parameter_passing() {
println!("\n🎯 Comprehensive parameter passing test (streaming + non-streaming)");
if let Ok(api_key) = std::env::var("OPENAI_API_KEY") {
println!(" 🔍 Testing OpenAI parameter passing...");
let client = Provider::openai()
.api_key(&api_key)
.model("gpt-4o-mini")
.temperature(0.3)
.max_tokens(15)
.build()
.await
.expect("Failed to create OpenAI client");
let messages = vec![user!("Say 'hello' in one word")];
match client.chat(messages.clone()).await {
Ok(response) => {
let content_str = match &response.content {
siumai::types::MessageContent::Text(text) => text.as_str(),
_ => "[non-text]",
};
println!(
" ✅ OpenAI non-streaming: {}",
content_str.chars().take(30).collect::<String>()
);
}
Err(e) => println!(" ⚠️ OpenAI non-streaming failed: {}", e),
}
match client.chat_stream(messages, None).await {
Ok(mut stream) => {
use futures_util::StreamExt;
let mut content = String::new();
let mut count = 0;
while let Some(event) = stream.next().await {
match event {
Ok(ChatStreamEvent::ContentDelta { delta, .. }) => {
content.push_str(&delta);
count += 1;
if count >= 3 {
break;
}
}
Ok(ChatStreamEvent::StreamEnd { .. }) => break,
Err(_) => break,
_ => {}
}
}
if !content.is_empty() {
println!(
" ✅ OpenAI streaming: {}",
content.chars().take(30).collect::<String>()
);
}
}
Err(e) => println!(" ⚠️ OpenAI streaming failed: {}", e),
}
} else {
println!(" ⏭️ Skipping OpenAI tests (no API key)");
}
if let Ok(api_key) = std::env::var("ANTHROPIC_API_KEY") {
println!(" 🔍 Testing Anthropic parameter passing...");
let client = Provider::anthropic()
.api_key(&api_key)
.model("claude-3-5-haiku-20241022")
.temperature(0.3)
.max_tokens(15)
.build()
.await
.expect("Failed to create Anthropic client");
let messages = vec![user!("Say 'hello' in one word")];
match client.chat(messages.clone()).await {
Ok(response) => {
let content_str = match &response.content {
siumai::types::MessageContent::Text(text) => text.as_str(),
_ => "[non-text]",
};
println!(
" ✅ Anthropic non-streaming: {}",
content_str.chars().take(30).collect::<String>()
);
}
Err(e) => println!(" ⚠️ Anthropic non-streaming failed: {}", e),
}
match client.chat_stream(messages, None).await {
Ok(mut stream) => {
use futures_util::StreamExt;
let mut content = String::new();
let mut count = 0;
while let Some(event) = stream.next().await {
match event {
Ok(ChatStreamEvent::ContentDelta { delta, .. }) => {
content.push_str(&delta);
count += 1;
if count >= 3 {
break;
}
}
Ok(ChatStreamEvent::StreamEnd { .. }) => break,
Err(_) => break,
_ => {}
}
}
if !content.is_empty() {
println!(
" ✅ Anthropic streaming: {}",
content.chars().take(30).collect::<String>()
);
}
}
Err(e) => println!(" ⚠️ Anthropic streaming failed: {}", e),
}
} else {
println!(" ⏭️ Skipping Anthropic tests (no API key)");
}
if let Ok(api_key) = std::env::var("XAI_API_KEY") {
println!(" 🔍 Testing xAI parameter passing...");
let client = Provider::xai()
.api_key(&api_key)
.model("grok-3")
.temperature(0.3)
.max_tokens(15)
.build()
.await
.expect("Failed to create xAI client");
let messages = vec![user!("Say 'hello' in one word")];
match client.chat(messages.clone()).await {
Ok(response) => {
let content_str = match &response.content {
siumai::types::MessageContent::Text(text) => text.as_str(),
_ => "[non-text]",
};
println!(
" ✅ xAI non-streaming: {}",
content_str.chars().take(30).collect::<String>()
);
}
Err(e) => println!(" ⚠️ xAI non-streaming failed: {}", e),
}
match client.chat_stream(messages, None).await {
Ok(mut stream) => {
use futures_util::StreamExt;
let mut content = String::new();
let mut count = 0;
while let Some(event) = stream.next().await {
match event {
Ok(ChatStreamEvent::ContentDelta { delta, .. }) => {
content.push_str(&delta);
count += 1;
if count >= 3 {
break;
}
}
Ok(ChatStreamEvent::StreamEnd { .. }) => break,
Err(_) => break,
_ => {}
}
}
if !content.is_empty() {
println!(
" ✅ xAI streaming: {}",
content.chars().take(30).collect::<String>()
);
}
}
Err(e) => println!(" ⚠️ xAI streaming failed: {}", e),
}
} else {
println!(" ⏭️ Skipping xAI tests (no API key)");
}
println!(" 🎯 Comprehensive parameter passing test completed!");
println!(" 💡 Both streaming and non-streaming modes tested for all available providers");
}