use std::future::Future;
pub(super) const STACK_BUDGET_BYTES: usize = 2 * 1024 * 1024;
pub(super) fn model_spec(
model: impl Into<String>,
variant: Option<String>,
context_window_tokens: usize,
) -> lash_core::ModelSpec {
let capability = capability_for_variant(variant.as_deref());
lash_core::ModelSpec::from_token_limits(model, variant, context_window_tokens, None)
.expect("valid model spec")
.with_capability(capability)
}
pub(super) fn mock_model_spec() -> lash_core::ModelSpec {
model_spec("mock-model", None, 200_000)
}
fn capability_for_variant(variant: Option<&str>) -> lash_core::ModelCapability {
let Some(variant) = variant else {
return lash_core::ModelCapability::default();
};
lash_core::ModelCapability {
reasoning: Some(lash_core::ReasoningCapability {
efforts: vec![variant.to_string()],
default_effort: None,
aliases: Default::default(),
encoding: lash_core::ReasoningEncoding::Effort,
mandatory: false,
}),
}
}
pub(super) fn run_async_test_on_stack_budget<F, Fut, T>(name: &str, test: F) -> T
where
F: FnOnce() -> Fut + Send + 'static,
Fut: Future<Output = T> + 'static,
T: Send + 'static,
{
run_async_test_on_stack_size(name, STACK_BUDGET_BYTES, test)
}
pub(super) fn run_async_test_on_stack_size<F, Fut, T>(name: &str, stack_size: usize, test: F) -> T
where
F: FnOnce() -> Fut + Send + 'static,
Fut: Future<Output = T> + 'static,
T: Send + 'static,
{
std::thread::Builder::new()
.name(name.to_string())
.stack_size(stack_size)
.spawn(|| {
let test = Box::pin(test());
tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("tokio runtime")
.block_on(test)
})
.expect("spawn stack-budget test thread")
.join()
.expect("stack-budget test thread")
}