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;
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,
}
}
}
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
}
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)
}
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 == '_'
}