Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

smith-harness/tests/fixtures/lifecycle.rs

Raw
//! Stateless raw-WIT lifecycle consumer (SMH-SPEC-PLUG0001, SMH-SPEC-SPEC0001).
wit_bindgen::generate!({ path: "wit", world: "lifecycle-world" });
use exports::smith::plugin::{plugin, provider::*, registration::*};
struct Plugin;
impl plugin::Guest for Plugin {
    fn declare_tools() -> Vec<plugin::ToolDeclaration> {
        vec![]
    }
    fn invoke(_: String, _: String) -> Result<String, String> {
        Err("no tools".into())
    }
}
impl exports::smith::plugin::registration::Guest for Plugin {
    fn declare() -> Registrations {
        Registrations {
            credential_sources: vec![],
            providers: vec![],
            models: vec![],
        }
    }
}
impl exports::smith::plugin::provider::Guest for Plugin {
    fn declare_settings() -> ProviderSettings {
        ProviderSettings {
            include_usage: true,
            subscription: false,
            provenance: SettingsProvenance::Explicit,
        }
    }
    fn validate_settings(settings: ProviderSettings) -> Result<ProviderSettings, String> {
        Ok(settings)
    }
    fn build_request(
        model: String,
        _: ProviderRequest,
        _: ProviderSettings,
        _: CatalogSnapshot,
    ) -> Result<RequestTemplate, String> {
        if model != "fixture-model" {
            return Err("wrong model".into());
        }
        Ok(RequestTemplate {
            url: "https://fixture.invalid/infer".into(),
            authorization: "Bearer {{secret:connection-api-key}}".into(),
            body: "custom-wire-request".into(),
        })
    }
    fn decode_response(
        mut state: Vec<u8>,
        chunk: Vec<u8>,
        finished: bool,
    ) -> Result<DecodeStep, String> {
        state.extend(chunk);
        if !finished {
            return Ok(DecodeStep {
                state,
                events: vec![],
            });
        }
        let text = String::from_utf8(state).map_err(|_| "invalid text".to_string())?;
        Ok(DecodeStep {
            state: vec![],
            events: vec![
                StreamEvent::Text(text),
                StreamEvent::Stop((StopReason::EndTurn, None)),
            ],
        })
    }
}
impl exports::smith::plugin::lifecycle::Guest for Plugin {
    fn declare_handlers() -> Vec<exports::smith::plugin::lifecycle::HandlerDeclaration> {
        use exports::smith::plugin::lifecycle::*;
        vec![HandlerDeclaration { name: "continue".into(), boundary: Boundary::TurnComplete, required_decision: false }]
    }
    fn handle(_: String, event: exports::smith::plugin::lifecycle::Event) -> Result<Vec<exports::smith::plugin::lifecycle::Action>, String> {
        use exports::smith::plugin::lifecycle::*;
        Ok(if event.round_index == 0 { vec![Action::EnsureContinuation] } else { vec![] })
    }
}
export!(Plugin);