use serde::{Deserialize, Serialize};
use crate::{CoreError, Digest};
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct LoraSpec {
pub artifact: Digest,
pub scale: f32,
}
impl LoraSpec {
pub fn validate(&self) -> Result<(), CoreError> {
if !self.scale.is_finite() {
return Err(CoreError::NonFinite {
field: "LoRA scale",
});
}
if self.scale == 0.0 {
return Err(CoreError::invalid("LoRA scale", "must be nonzero"));
}
Ok(())
}
pub fn digest(&self) -> Result<Digest, CoreError> {
self.validate()?;
Digest::of_serializable("lora-spec-v1", self)
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ControlVectorSpec {
pub data: Digest,
pub embedding_width: u32,
pub layer_start: i32,
pub layer_end: i32,
}
impl ControlVectorSpec {
pub fn validate(&self) -> Result<(), CoreError> {
if self.embedding_width == 0 || self.layer_start < 1 || self.layer_end < self.layer_start {
return Err(CoreError::invalid(
"control vector",
"embedding width must be nonzero and inclusive layer range must start at one",
));
}
Ok(())
}
pub fn digest(&self) -> Result<Digest, CoreError> {
self.validate()?;
Digest::of_serializable("control-vector-spec-v1", self)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SteeringKind {
Lora,
ControlVector,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SteeringAction {
Applied,
Cleared,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct SteeringReceipt {
pub kind: SteeringKind,
pub resource: Digest,
pub action: SteeringAction,
pub position: u64,
}
impl SteeringReceipt {
pub fn digest(&self) -> Result<Digest, CoreError> {
Digest::of_serializable("steering-receipt-v1", self)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn control_vector_uses_an_inclusive_nonzero_layer_range() {
let data = Digest::of_bytes("test-vector", b"one");
let valid = ControlVectorSpec {
data: data.clone(),
embedding_width: 4,
layer_start: 1,
layer_end: 1,
};
assert!(valid.validate().is_ok());
assert!(
ControlVectorSpec {
data,
embedding_width: 4,
layer_start: 0,
layer_end: 1,
}
.validate()
.is_err()
);
}
#[test]
fn lora_scale_must_be_finite_and_nonzero() {
let artifact = Digest::of_bytes("test-lora", b"one");
for scale in [0.0, f32::NAN, f32::INFINITY] {
assert!(
LoraSpec {
artifact: artifact.clone(),
scale,
}
.validate()
.is_err()
);
}
}
}