Skip to content

AI media harness for planning, generating, and editing locally

TypeScript
5.2 KB
Raw Blame
use super::{ModelDefinition, SceneDefaults};
use crate::project::SceneShot;
use std::sync::LazyLock;

pub(crate) static MODEL: ModelDefinition = ModelDefinition {
    defaults: SceneDefaults {
        provider_id: "minimax-h3",
        duration_seconds: 6.0,
    },
    capabilities: slopus_core::models::H3_CAPABILITIES,
    shot_catalog,
    validate_shot_settings: validate_agent_shot_settings,
    agent_instructions: include_str!("../../../assets/h3-agent.md"),
};

#[derive(serde::Deserialize)]
#[serde(rename_all = "camelCase")]
struct ShotGroup {
    id: String,
    multiple: bool,
    #[serde(default)]
    scene_wide: bool,
    options: Vec<ShotOption>,
}
#[derive(serde::Deserialize)]
struct ShotOption {
    id: String,
}
static GROUPS: LazyLock<Vec<ShotGroup>> = LazyLock::new(|| {
    serde_json::from_str(include_str!(
        "../../../../shared/models/minimax-h3-shot-tags.json"
    ))
    .expect("bundled H3 vocabulary")
});
pub(crate) fn shot_catalog() -> String {
    GROUPS
        .iter()
        .map(|group| {
            format!(
                "- {}: {}",
                group.id,
                group
                    .options
                    .iter()
                    .map(|option| option.id.as_str())
                    .collect::<Vec<_>>()
                    .join(", ")
            )
        })
        .collect::<Vec<_>>()
        .join("\n")
}
fn agent_setting_options(group: &str) -> Option<Vec<&'static str>> {
    GROUPS
        .iter()
        .find(|candidate| candidate.id == group)
        .map(|group| {
            group
                .options
                .iter()
                .map(|option| option.id.as_str())
                .collect()
        })
}
fn shot_setting_values<'a>(shot: Option<&'a SceneShot>, group: &str) -> &'a [String] {
    shot.and_then(|value| value.settings.as_ref())
        .and_then(|settings| settings.get(group))
        .map(Vec::as_slice)
        .unwrap_or_default()
}

pub(crate) fn validate_agent_shot_settings(
    before: Option<&SceneShot>,
    shot: &SceneShot,
    earliest_shot_id: &str,
) -> Result<(), String> {
    if before.and_then(|value| value.settings.as_ref()) == shot.settings.as_ref() {
        return Ok(());
    }
    let Some(settings) = shot.settings.as_ref() else {
        return Ok(());
    };
    for (group, values) in settings {
        let before_values = shot_setting_values(before, group);
        if before_values == values {
            continue;
        }
        let allowed = agent_setting_options(group).ok_or_else(|| {
            format!(
                "Shot '{}' introduces unsupported Settings group '{}'. Use only the supported shot.settings catalog.",
                shot.id, group
            )
        })?;
        for option in values {
            if !allowed.contains(&option.as_str()) && !before_values.contains(option) {
                return Err(format!(
                    "Shot '{}' introduces unsupported Settings option '{}.{}'. Use an exact option id from the supported catalog.",
                    shot.id, group, option
                ));
            }
        }
        if !GROUPS
            .iter()
            .find(|candidate| candidate.id == *group)
            .is_some_and(|group| group.multiple)
            && values.len() > 1
        {
            return Err(format!(
                "Shot '{}' gives single-choice Settings group '{}' more than one option.",
                shot.id, group
            ));
        }
        if GROUPS
            .iter()
            .find(|candidate| candidate.id == *group)
            .is_some_and(|group| group.scene_wide)
            && shot.id != earliest_shot_id
        {
            return Err(format!(
                "Shot '{}' puts scene Look on a later shot. Store visualStyle on the earliest shot only.",
                shot.id
            ));
        }
    }

    let movement = settings
        .get("cameraMovement")
        .map(Vec::as_slice)
        .unwrap_or_default();
    let speed = settings
        .get("cameraSpeed")
        .map(Vec::as_slice)
        .unwrap_or_default();
    let amplitude = settings
        .get("cameraAmplitude")
        .map(Vec::as_slice)
        .unwrap_or_default();
    let movement_controls_changed = ["cameraMovement", "cameraSpeed", "cameraAmplitude"]
        .iter()
        .any(|group| shot_setting_values(before, group) != shot_setting_values(Some(shot), group));
    if movement_controls_changed {
        if movement.contains(&"static-shot".to_string()) {
            if movement.len() > 1 || !speed.is_empty() || !amplitude.is_empty() {
                return Err(format!(
                    "Shot '{}' combines static-shot with another movement, speed, or amplitude.",
                    shot.id
                ));
            }
        } else if !movement.is_empty() && (speed.len() != 1 || amplitude.len() != 1) {
            return Err(format!(
                "Shot '{}' has camera movement but does not define exactly one cameraSpeed and cameraAmplitude.",
                shot.id
            ));
        } else if movement.is_empty() && (!speed.is_empty() || !amplitude.is_empty()) {
            return Err(format!(
                "Shot '{}' defines cameraSpeed or cameraAmplitude without cameraMovement.",
                shot.id
            ));
        }
    }
    Ok(())
}