OpenAI Provider

# Configure using the CLI
goose configure

# Or set environment variables
export OPENAI_API_KEY="sk-..."
export OPENAI_HOST="https://api.openai.com"
export OPENAI_ORGANIZATION="org-..."
export OPENAI_PROJECT="proj_..."

use goose::providers::create;
use goose::model::ModelConfig;
use goose::conversation::message::Message;

// Create with default model (gpt-4o)
let model_config = ModelConfig::new("gpt-4o")?;
let provider = create("openai", model_config, vec![]).await?;

// Stream a response
let messages = vec![Message::user().with_text("Hello, GPT-4!")];
let stream = provider.stream(
    &provider.get_model_config(),
    "session-123",
    "You are a helpful assistant.",
    &messages,
    &[],
).await?;

let model_config = ModelConfig::new("gpt-4-turbo")?
    .with_temperature(0.7)
    .with_max_tokens(2048)
    .with_top_p(0.95);

let provider = create("openai", model_config, vec![]).await?;

// Automatically tries gpt-4o-mini, falls back to main model on failure
let (response, usage) = provider.complete_fast(
    "session-123",
    "You are a helpful assistant.",
    &messages,
    &[],
).await?;

if provider.supports_embeddings() {
    let texts = vec![
        "Hello world".to_string(),
        "How are you?".to_string(),
    ];
    
    let embeddings = provider.create_embeddings(
        "session-123",
        texts,
    ).await?;
    
    // embeddings is Vec<Vec<f32>>
    println!("Embedding dimension: {}", embeddings[0].len());
}

export OPENAI_ORGANIZATION="org-abc123"
export OPENAI_PROJECT="proj_xyz789"

OpenAI-Organization: org-abc123
OpenAI-Project: proj_xyz789

export OPENAI_CUSTOM_HEADERS="X-Custom-Header=value1,X-Another=value2"

let model_config = ModelConfig::new("gpt-5-codex")?;
let provider = create("openai", model_config, vec![]).await?;

// Automatically uses /v1/responses endpoint instead of /v1/chat/completions

export OPENAI_BASE_PATH="v1/responses"

export OPENAI_API_KEY="not-needed"
export OPENAI_HOST="http://localhost:8000"
export OPENAI_BASE_PATH="v1/chat/completions"

export OPENAI_API_KEY="your-azure-key"
export OPENAI_HOST="https://your-resource.openai.azure.com"
export OPENAI_BASE_PATH="openai/deployments/your-deployment/chat/completions?api-version=2024-02-15-preview"

impl ProviderDef for OpenAiProvider {
    fn metadata() -> ProviderMetadata {
        ProviderMetadata::with_models(
            "openai",
            "OpenAI",
            "GPT-4 and other OpenAI models, including OpenAI compatible ones",
            "gpt-4o",
            models,
            "https://platform.openai.com/docs/models",
            vec![
                ConfigKey::new("OPENAI_API_KEY", false, true, None, true),
                ConfigKey::new("OPENAI_HOST", true, false, Some("https://api.openai.com"), false),
                ConfigKey::new("OPENAI_BASE_PATH", true, false, Some("v1/chat/completions"), false),
                ConfigKey::new("OPENAI_ORGANIZATION", false, false, None, false),
                ConfigKey::new("OPENAI_PROJECT", false, false, None, false),
                ConfigKey::new("OPENAI_CUSTOM_HEADERS", false, true, None, false),
                ConfigKey::new("OPENAI_TIMEOUT", false, false, Some("600"), false),
            ],
        )
    }
}

{
  "model": "gpt-4o",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful assistant."
    },
    {
      "role": "user",
      "content": "Hello!"
    }
  ],
  "temperature": 0.7,
  "max_tokens": 2048,
  "stream": true
}

let auth = AuthMethod::BearerToken(api_key);

let auth = AuthMethod::NoAuth;

data: {"choices":[{"delta":{"content":"Hello"}}]}
data: {"choices":[{"delta":{"content":" world"}}]}
data: [DONE]

// Automatically maps chat/completions to responses for codex models
if model_name.contains("codex") {
    // Uses /v1/responses instead of /v1/chat/completions
}

// Maps to models endpoint for model listing
let models_path = map_base_path(base_path, "models", "v1/models");

match provider.stream(...).await {
    Ok(stream) => { /* handle stream */ },
    Err(ProviderError::Authentication(msg)) => {
        eprintln!("Invalid API key: {}", msg);
    },
    Err(ProviderError::RateLimited { retry_after }) => {
        eprintln!("Rate limited");
    },
    Err(ProviderError::ContextLengthExceeded(msg)) => {
        eprintln!("Context too long: {}", msg);
    },
    Err(e) => eprintln!("Error: {}", e),
}

// Get all available models
let models = provider.fetch_supported_models().await?;

// Returns Vec<String> of model IDs
for model in models {
    println!("Available model: {}", model);
}

let (message, usage) = provider.complete(...).await?;

println!("Model: {}", usage.model);
println!("Input tokens: {:?}", usage.usage.input_tokens);
println!("Output tokens: {:?}", usage.usage.output_tokens);
println!("Total tokens: {:?}", usage.usage.total_tokens);

use goose::config::declarative_providers::DeclarativeProviderConfig;
use goose::providers::openai::OpenAiProvider;

let config = DeclarativeProviderConfig {
    name: "my-provider".to_string(),
    engine: ProviderEngine::OpenAI,
    base_url: "http://localhost:8000".to_string(),
    // ... other fields
};

let provider = OpenAiProvider::from_custom_config(model_config, config)?;