use std::collections::HashMap;
use serde::Serialize;
use wasm_bindgen::prelude::*;
use crate::cache::TtlCache;
use crate::cost::{known_models, pricing_for_model, CostLedger};
use crate::format::{JsonFormatter, MarkdownFormatter};
use crate::guard::{ContentGuard, GuardChain, LengthGuard};
use crate::retry::RetryPolicy;
use crate::routing::{Router, RoutingRule};
use crate::template::TemplateEngine;
use crate::types::ChatRequest;
use crate::LlmWasmError;
fn js_err(e: LlmWasmError) -> JsError {
JsError::new(&e.to_string())
}
fn from_js<T: serde::de::DeserializeOwned>(v: JsValue, what: &str) -> Result<T, JsError> {
serde_wasm_bindgen::from_value(v).map_err(|e| JsError::new(&format!("invalid {what}: {e}")))
}
fn to_js<T: Serialize>(v: &T) -> Result<JsValue, JsError> {
v.serialize(&serde_wasm_bindgen::Serializer::json_compatible())
.map_err(|e| JsError::new(&e.to_string()))
}
#[wasm_bindgen(js_name = estimateCost)]
pub fn estimate_cost(model: &str, input_tokens: u32, output_tokens: u32) -> Result<f64, JsError> {
Ok(pricing_for_model(model)
.map_err(js_err)?
.cost_usd(input_tokens, output_tokens))
}
#[wasm_bindgen(js_name = knownModels)]
pub fn known_models_js() -> Vec<String> {
known_models().map(str::to_string).collect()
}
#[wasm_bindgen(js_name = extractJson)]
pub fn extract_json(text: &str) -> Result<JsValue, JsError> {
to_js(&JsonFormatter::extract_json(text).map_err(js_err)?)
}
#[wasm_bindgen(js_name = stripCodeFence)]
pub fn strip_code_fence(text: &str) -> String {
MarkdownFormatter::strip_code_fence(text)
}
#[wasm_bindgen(js_name = renderTemplate)]
pub fn render_template(
template: &str,
vars: JsValue,
partials: JsValue,
) -> Result<String, JsError> {
let vars: HashMap<String, String> = from_js(vars, "vars")?;
let mut engine = TemplateEngine::new();
if !partials.is_undefined() && !partials.is_null() {
let partials: HashMap<String, String> = from_js(partials, "partials")?;
for (name, body) in &partials {
engine.register_partial(name, body);
}
}
engine.render(template, &vars).map_err(js_err)
}
#[wasm_bindgen(js_name = checkRequest)]
pub fn check_request(
request: JsValue,
blocklist: Vec<String>,
max_chars: usize,
) -> Result<(), JsError> {
let request: ChatRequest = from_js(request, "request")?;
GuardChain::new()
.add(ContentGuard::new(blocklist))
.add(LengthGuard::new(max_chars))
.check(&request)
.map(|_| ())
.map_err(js_err)
}
#[wasm_bindgen(js_name = routeModel)]
pub fn route_model(request: JsValue, rules: JsValue, fallback: &str) -> Result<String, JsError> {
let request: ChatRequest = from_js(request, "request")?;
let rules: Vec<RoutingRule> = from_js(rules, "rules")?;
let mut router = Router::new(fallback);
for rule in rules {
router.add_rule(rule);
}
Ok(router.route(&request).to_string())
}
#[wasm_bindgen]
pub struct Ledger {
inner: CostLedger,
}
#[wasm_bindgen]
impl Ledger {
#[wasm_bindgen(constructor)]
pub fn new(budget_usd: Option<f64>) -> Ledger {
Ledger {
inner: budget_usd.map_or_else(CostLedger::new, CostLedger::with_budget),
}
}
pub fn record(
&mut self,
model: &str,
input_tokens: u32,
output_tokens: u32,
) -> Result<f64, JsError> {
self.inner
.record(model, input_tokens, output_tokens)
.map_err(js_err)
}
#[wasm_bindgen(js_name = recordUsd)]
pub fn record_usd(&mut self, cost_usd: f64) -> Result<f64, JsError> {
self.inner.record_usd(cost_usd).map_err(js_err)
}
#[wasm_bindgen(getter)]
pub fn total(&self) -> f64 {
self.inner.total_usd()
}
#[wasm_bindgen(getter)]
pub fn remaining(&self) -> Option<f64> {
self.inner.remaining_usd()
}
}
#[wasm_bindgen]
pub struct Retry {
inner: RetryPolicy,
}
#[wasm_bindgen]
impl Retry {
#[wasm_bindgen(constructor)]
pub fn new(max_attempts: u32, base_delay_ms: u32, max_delay_ms: u32) -> Result<Retry, JsError> {
Ok(Retry {
inner: RetryPolicy::new(max_attempts, base_delay_ms, max_delay_ms).map_err(js_err)?,
})
}
#[wasm_bindgen(js_name = shouldRetry)]
pub fn should_retry(&self, attempt: u32, status: u16) -> bool {
self.inner.should_retry(attempt, status)
}
pub fn delay(&self, attempt: u32, random_unit: f64, retry_after: Option<String>) -> u32 {
self.inner
.delay_for_response(attempt, retry_after.as_deref(), random_unit)
}
}
#[wasm_bindgen]
pub struct Cache {
inner: TtlCache<String>,
}
#[wasm_bindgen]
impl Cache {
#[wasm_bindgen(constructor)]
pub fn new(ttl_ms: f64, max_entries: Option<usize>) -> Cache {
let inner = match max_entries {
Some(n) => TtlCache::with_capacity(ttl_ms, n),
None => TtlCache::new(ttl_ms),
};
Cache { inner }
}
pub fn get(&mut self, key: &str, now_ms: f64) -> Option<String> {
self.inner.get(&key.to_string(), now_ms)
}
pub fn set(&mut self, key: &str, value: &str, now_ms: f64) {
self.inner.set(key.to_string(), value.to_string(), now_ms);
}
#[wasm_bindgen(getter)]
pub fn size(&self) -> usize {
self.inner.len()
}
}
#[cfg(feature = "repair")]
#[wasm_bindgen(js_name = extractJsonLenient)]
pub fn extract_json_lenient(text: &str) -> Result<JsValue, JsError> {
to_js(&JsonFormatter::extract_json_lenient(text).map_err(js_err)?)
}
#[cfg(feature = "jinja")]
#[wasm_bindgen(js_name = renderChatTemplate)]
pub fn render_chat_template(
template: &str,
messages: JsValue,
add_generation_prompt: bool,
bos_token: Option<String>,
eos_token: Option<String>,
) -> Result<String, JsError> {
let messages: Vec<crate::types::ChatMessage> = from_js(messages, "messages")?;
crate::template::render_chat_template(
template,
&messages,
add_generation_prompt,
bos_token.as_deref().unwrap_or(""),
eos_token.as_deref().unwrap_or(""),
)
.map_err(js_err)
}
#[cfg(feature = "secrets")]
#[wasm_bindgen(js_name = redactSecrets)]
pub fn redact_secrets(text: &str) -> String {
crate::secrets::SecretGuard::redact().redact_text(text)
}
#[cfg(feature = "stream")]
#[wasm_bindgen(js_name = StreamDecoder)]
pub struct JsStreamDecoder {
inner: crate::stream::StreamDecoder,
}
#[cfg(feature = "stream")]
#[wasm_bindgen(js_class = StreamDecoder)]
impl JsStreamDecoder {
#[wasm_bindgen(constructor)]
pub fn new() -> JsStreamDecoder {
JsStreamDecoder {
inner: crate::stream::StreamDecoder::new(),
}
}
pub fn push(&mut self, bytes: &[u8]) -> Result<Vec<String>, JsError> {
let chunks = self.inner.push(bytes).map_err(js_err)?;
Ok(chunks
.into_iter()
.map(|c| c.delta)
.filter(|d| !d.is_empty())
.collect())
}
#[wasm_bindgen(getter)]
pub fn finished(&self) -> bool {
self.inner.is_finished()
}
#[wasm_bindgen(getter)]
pub fn text(&self) -> String {
self.inner.text().to_string()
}
#[wasm_bindgen(getter)]
pub fn usage(&self) -> Result<JsValue, JsError> {
match self.inner.usage() {
Some(u) => to_js(&u),
None => Ok(JsValue::UNDEFINED),
}
}
}
#[cfg(feature = "stream")]
impl Default for JsStreamDecoder {
fn default() -> Self {
Self::new()
}
}