oxicode-sdk 0.65.0

oxicode AI agent SDK — build isolated, multi-agent AI systems
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! Env-gated smoke tests — exercise real provider paths.
//!
//! These tests run only when ANTHROPIC_API_KEY (or OPENAI_API_KEY) is set.
//! Without a key, they are silently skipped (not failed).

use oxicode_sdk::SdkError;
use oxicode_sdk::prelude::*;

/// Helper: skip if no Anthropic key.
fn anthropic_key() -> Option<String> {
    std::env::var("ANTHROPIC_API_KEY")
        .ok()
        .filter(|s| !s.is_empty())
}

/// Helper: skip if no OpenAI key.
fn openai_key() -> Option<String> {
    std::env::var("OPENAI_API_KEY")
        .ok()
        .filter(|s| !s.is_empty())
}

#[test]
fn model_resolution_smoke() {
    if std::env::var("SMOKE").ok().as_deref() != Some("1") {
        return;
    }

    let oxicode = OxicodeBuilder::new().with_builtins().build();
    let model = oxicode
        .resolve_model("anthropic/claude-sonnet-4-20250514")
        .expect("built-in Anthropic model should resolve");
    assert_eq!(model.provider, "anthropic");
    assert_eq!(model.id, "claude-sonnet-4-20250514");
    assert_eq!(model.api, oxicode_ai::Api::AnthropicMessages);
}

#[tokio::test]
async fn provider_creation_smoke() {
    if anthropic_key().is_none() {
        return;
    }

    let oxicode = OxicodeBuilder::new().with_builtins().build();
    oxicode
        .create_provider("anthropic")
        .expect("Anthropic provider should be created with an API key");
}

#[tokio::test]
async fn agent_run_smoke() {
    if anthropic_key().is_none() {
        return;
    }

    let oxicode = OxicodeBuilder::new().with_builtins().build();
    let agent = oxicode
        .agent(AgentConfig {
            model_id: "anthropic/claude-sonnet-4-20250514".into(),
            ..Default::default()
        })
        .system_prompt("Reply briefly and follow the user's requested format exactly.")
        .build()
        .expect("agent should build with Anthropic credentials");
    let (response, _) = agent
        .run("Reply with exactly: OK".into())
        .await
        .expect("Anthropic request should succeed");
    assert!(!response.content.trim().is_empty());
}

#[test]
fn error_path_smoke() {
    let oxicode = OxicodeBuilder::new().with_builtins().build();
    let err = oxicode
        .resolve_model("nonexistent/fake")
        .expect_err("unknown model should fail");
    assert!(matches!(err, SdkError::ModelNotFound { .. }));
}

#[test]
fn provider_not_found_structured() {
    let oxicode = OxicodeBuilder::new().with_builtins().build();
    match oxicode.create_provider("nonexistent-provider") {
        Err(err) => assert!(
            matches!(err, SdkError::ProviderNotFound { .. }),
            "expected ProviderNotFound, got: {err:?}"
        ),
        Ok(_) => panic!("unknown provider should fail"),
    }
}

#[allow(dead_code)]
fn _openai_key_helper_is_available() -> Option<String> {
    openai_key()
}