widevin 0.3.0

Lightweight Rust Devin provider library
Documentation
use crate::{
    DevinClientMetadata, DevinError, DevinInput, DevinModel, FetchLike,
    constants::{
        DEVIN_DEFAULT_BASE_URL, DEVIN_EXTENSION_VERSION, DEVIN_IDE_VERSION, DEVIN_MODELS_PATH,
        trim_trailing_slashes,
    },
    fetch::default_fetch,
    normalize_devin_session_token,
    proto::{ClientModelConfig, GetCliModelConfigsRequest, GetCliModelConfigsResponse, Metadata},
    unary::{decode_unary_response, request_unary},
};
use indexmap::IndexMap;
use prost::Message;

const DEFAULT_CONTEXT_WINDOW: i32 = 200_000;
const DEFAULT_MAX_TOKENS: i32 = 64_000;
const MODEL_ROUTER_DISPLAY: i32 = 3;
// Quick review (4) and internal default (6); the vendored enum predates slot 6.
const INTERNAL_MODEL_DISPLAYS: [i32; 2] = [4, 6];

#[derive(Clone)]
pub struct ListDevinModelsOptions {
    pub token: Option<String>,
    pub base_url: String,
    pub fetch: Option<FetchLike>,
    pub client_metadata: Option<DevinClientMetadata>,
}

impl Default for ListDevinModelsOptions {
    fn default() -> Self {
        Self {
            token: None,
            base_url: DEVIN_DEFAULT_BASE_URL.into(),
            fetch: None,
            client_metadata: None,
        }
    }
}

/// Discovers and normalizes the enabled Devin models.
///
/// # Errors
///
/// Returns [`DevinError::Api`] for transport/HTTP failures and
/// [`DevinError::Protocol`] for malformed protobuf responses.
pub async fn list_devin_models(
    options: ListDevinModelsOptions,
) -> Result<Vec<DevinModel>, DevinError> {
    let fetch = options.fetch.clone().unwrap_or_else(default_fetch);
    let native = fetch_catalog(
        &options,
        &fetch,
        discovery_metadata(
            &normalize_devin_session_token(options.token.as_deref()),
            options.client_metadata.as_ref(),
        ),
    )
    .await;
    if let Ok(models) = &native {
        if !models.is_empty()
            && !models
                .iter()
                .all(|model| matches!(model.id.as_str(), "swe-1-6" | "swe-1-6-fast"))
        {
            return native;
        }
    }
    let legacy = fetch_catalog(
        &options,
        &fetch,
        legacy_metadata(
            options.token.as_deref().unwrap_or_default(),
            options.client_metadata.as_ref(),
        ),
    )
    .await;
    match (native, legacy) {
        (Ok(native), Ok(legacy)) if legacy.len() > native.len() => Ok(legacy),
        (Ok(native), _) => Ok(native),
        (Err(_), Ok(legacy)) => Ok(legacy),
        (Err(error), Err(_)) => Err(error),
    }
}

async fn fetch_catalog(
    options: &ListDevinModelsOptions,
    fetch: &FetchLike,
    identity: Metadata,
) -> Result<Vec<DevinModel>, DevinError> {
    let request = GetCliModelConfigsRequest {
        metadata: Some(identity),
    };
    let response = request_unary(
        format!(
            "{}{}",
            trim_trailing_slashes(&options.base_url),
            DEVIN_MODELS_PATH
        ),
        request.encode_to_vec(),
        fetch,
    )
    .await?;
    let decoded: GetCliModelConfigsResponse = decode_unary_response("model discovery", &response)?;
    let mut models = normalize_models(&decoded.client_model_configs, &options.base_url);
    if let Some(default) = decoded.default_override_model_config {
        for model in &mut models {
            model.is_provider_default = model.id == default.model_uid.trim();
        }
    }
    Ok(models)
}

pub fn normalize_models(configs: &[ClientModelConfig], base_url: &str) -> Vec<DevinModel> {
    let mut live = IndexMap::new();
    for config in configs {
        let uid = config.model_uid.trim();
        if !config.disabled && !uid.is_empty() {
            live.entry(uid).or_insert(config);
        }
    }
    let mut models = Vec::new();
    for (uid, config) in &live {
        if config
            .model_info
            .as_ref()
            .is_some_and(|info| INTERNAL_MODEL_DISPLAYS.contains(&info.display_option))
        {
            continue;
        }
        let mut spec = model_spec(config, base_url);
        if let Some((lead, _)) = uid
            .strip_prefix("fusion-")
            .and_then(|uid| uid.split_once("-sidekick-"))
            .filter(|(lead, _)| !lead.is_empty())
        {
            let Some(lead_config) = resolve_fusion_lead(lead, &live) else {
                continue;
            };
            let lead_spec = model_spec(lead_config, base_url);
            spec.request_model_id = Some(lead_spec.id);
            spec.model_router = false;
            spec.reasoning = lead_spec.reasoning;
            spec.input = lead_spec.input;
            spec.supports_tools = lead_spec.supports_tools;
            spec.supports_parallel_tool_calls = lead_spec.supports_parallel_tool_calls;
            spec.context_window = lead_spec.context_window;
            spec.max_tokens = lead_spec.max_tokens;
            spec.cost = lead_spec.cost;
        }
        models.push(spec);
    }
    models.sort_by(|a, b| a.id.cmp(&b.id));
    models
}

/// Exact live UIDs win before interpreting a pairing's optional fast lane.
fn resolve_fusion_lead<'a>(
    lead: &str,
    live: &IndexMap<&str, &'a ClientModelConfig>,
) -> Option<&'a ClientModelConfig> {
    if let Some(config) = live.get(lead) {
        return Some(*config);
    }
    let base = lead.strip_suffix("-fast")?;
    live.get(format!("{base}-priority").as_str())
        .or_else(|| live.get(base))
        .copied()
}

fn model_spec(config: &ClientModelConfig, base_url: &str) -> DevinModel {
    let uid = config.model_uid.trim();
    let info = config.model_info.as_ref();
    let features = info.and_then(|info| info.model_features.as_ref());
    let images = features.map_or(config.supports_images, |features| features.supports_images)
        && !matches!(uid, "swe-1-6" | "swe-1-6-fast");
    let router = info
        .is_some_and(|info| info.display_option == MODEL_ROUTER_DISPLAY || info.is_model_router);
    DevinModel {
        id: uid.into(),
        name: if config.label.trim().is_empty() {
            uid.into()
        } else {
            config.label.trim().into()
        },
        provider: "devin",
        base_url: base_url.into(),
        input: if images {
            vec![DevinInput::Text, DevinInput::Image]
        } else {
            vec![DevinInput::Text]
        },
        supports_tools: features.is_none_or(|features| features.supports_tool_calls),
        supports_parallel_tool_calls: features
            .is_some_and(|features| features.supports_parallel_tool_calls),
        reasoning: supports_thinking(config),
        context_window: if config.max_tokens > 0 {
            config.max_tokens
        } else {
            DEFAULT_CONTEXT_WINDOW
        },
        max_tokens: info
            .filter(|info| info.max_output_tokens > 0)
            .map_or(DEFAULT_MAX_TOKENS, |info| info.max_output_tokens),
        model_router: router && info.is_none_or(|info| info.harness_uids.is_empty()),
        description: config
            .description
            .as_deref()
            .map(str::trim)
            .filter(|value| !value.is_empty())
            .map(str::to_owned),
        is_new: config.is_new,
        is_beta: config.is_beta,
        is_recommended: config.is_recommended,
        family: config
            .model_family_metadata
            .as_ref()
            .map(|family| crate::DevinModelFamily {
                label: family.model_family_label.clone(),
                is_default: config.is_default_model_in_family || family.is_default_model_in_family,
                entries: family
                    .entries
                    .iter()
                    .filter_map(|entry| {
                        entry
                            .value
                            .as_ref()
                            .map(|value| crate::DevinModelFamilyEntry {
                                key: entry.key.clone(),
                                name: value.name.clone(),
                                order: value.order,
                            })
                    })
                    .collect(),
            }),
        cost: model_cost(config),
        ..Default::default()
    }
}

fn model_cost(config: &ClientModelConfig) -> crate::DevinModelCost {
    let mut cost = crate::DevinModelCost::default();
    for dimension in &config.model_dimensions {
        let label = dimension.label.trim().to_lowercase();
        if label == "sidekick" {
            break;
        }
        if !matches!(dimension.kind, 1 | 2) {
            continue;
        }
        let denominator = dimension.denominator.trim().to_lowercase();
        let start = denominator.find(|c: char| c.is_ascii_digit());
        let tokens = start
            .and_then(|start| {
                let rest = &denominator[start..];
                let end = rest
                    .find(|c: char| !c.is_ascii_digit() && c != '.')
                    .unwrap_or(rest.len());
                let number = rest[..end].parse::<f64>().ok()?;
                let scale = match rest[end..].trim_start().chars().next() {
                    Some('k') => 1e3,
                    Some('m') => 1e6,
                    Some('b') => 1e9,
                    _ => 1.0,
                };
                Some(number * scale)
            })
            .filter(|tokens| *tokens > 0.0)
            .unwrap_or(1e6);
        let rate = (f64::from(dimension.value) * 1e6 / tokens * 1e6).round() / 1e6;
        match label.as_str() {
            "input" => cost.input = rate,
            "output" => cost.output = rate,
            "cached input" => cost.cache_read = rate,
            _ => {}
        }
    }
    cost
}

pub fn metadata(api_key: &str, user_jwt: &str) -> Metadata {
    metadata_with_client_metadata(api_key, user_jwt, None)
}

/// Builds request metadata using released Devin CLI defaults plus optional
/// organization-approved client identity overrides.
pub fn metadata_with_client_metadata(
    api_key: &str,
    user_jwt: &str,
    client_metadata: Option<&DevinClientMetadata>,
) -> Metadata {
    let client_metadata = client_metadata.cloned().unwrap_or_default();
    Metadata {
        api_key: api_key.into(),
        user_jwt: user_jwt.into(),
        ide_name: client_metadata
            .ide_name
            .unwrap_or_else(|| "devin-cli".into()),
        ide_version: client_metadata
            .ide_version
            .unwrap_or_else(|| DEVIN_IDE_VERSION.into()),
        ide_type: client_metadata.ide_type.unwrap_or_else(|| "chisel".into()),
        extension_name: client_metadata
            .extension_name
            .unwrap_or_else(|| "chisel".into()),
        extension_version: client_metadata
            .extension_version
            .unwrap_or_else(|| DEVIN_EXTENSION_VERSION.into()),
        locale: client_metadata.locale.unwrap_or_else(|| "en".into()),
        os: client_metadata.os.unwrap_or_else(|| platform_os().into()),
        supported_model_displays: Vec::new(),
    }
}

fn platform_os() -> &'static str {
    if cfg!(target_os = "macos") {
        "darwin"
    } else if cfg!(target_os = "windows") {
        "windows"
    } else {
        "linux"
    }
}

fn discovery_metadata(api_key: &str, overrides: Option<&DevinClientMetadata>) -> Metadata {
    let mut identity = metadata_with_client_metadata(api_key, "", overrides);
    let overrides = overrides.cloned().unwrap_or_default();
    identity.ide_name = overrides.ide_name.unwrap_or_else(|| "chisel".into());
    identity.ide_type = overrides.ide_type.unwrap_or_default();
    identity.ide_version = overrides.ide_version.unwrap_or_else(|| "0.0.0-dev".into());
    identity.extension_version = overrides
        .extension_version
        .unwrap_or_else(|| "0.0.0-dev".into());
    identity.supported_model_displays = vec![3, 4, 6, 7, 8];
    identity
}

fn legacy_metadata(api_key: &str, overrides: Option<&DevinClientMetadata>) -> Metadata {
    let mut identity = metadata_with_client_metadata(api_key, "", overrides);
    let overrides = overrides.cloned().unwrap_or_default();
    identity.ide_name = overrides.ide_name.unwrap_or_else(|| "windsurf".into());
    identity.ide_type = overrides.ide_type.unwrap_or_default();
    identity.ide_version = overrides.ide_version.unwrap_or_else(|| "3.2.23".into());
    identity.extension_name = overrides
        .extension_name
        .unwrap_or_else(|| "windsurf".into());
    identity.extension_version = overrides
        .extension_version
        .unwrap_or_else(|| "1.48.2".into());
    identity.os = overrides.os.unwrap_or_default();
    identity
}

fn supports_thinking(config: &ClientModelConfig) -> bool {
    if let Some(features) = config
        .model_info
        .as_ref()
        .and_then(|info| info.model_features.as_ref())
    {
        return features.supports_thinking;
    }
    let label = config.label.to_lowercase();
    if contains_ascii_word_phrase(&label, "no thinking") {
        return false;
    }
    [
        "think",
        "thinking",
        "minimal",
        "high",
        "medium",
        "low",
        "xhigh",
        "max",
        "reasoning",
    ]
    .iter()
    .any(|term| label.contains(term))
}

fn contains_ascii_word_phrase(value: &str, phrase: &str) -> bool {
    value.match_indices(phrase).any(|(start, matched)| {
        let before = value[..start].chars().next_back();
        let after = value[start + matched.len()..].chars().next();
        before.is_none_or(|character| !is_ascii_word(character))
            && after.is_none_or(|character| !is_ascii_word(character))
    })
}

fn is_ascii_word(character: char) -> bool {
    character.is_ascii_alphanumeric() || character == '_'
}