Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

smith-harness/tests/fixtures/composition.rs

Raw
//! SMH-SPEC-PLUG0001: independent callers compose through a real filesystem target.
#![expect(missing_docs, reason = "wit-bindgen generates the world surface")]
#![expect(clippy::pedantic, reason = "wit-bindgen generates the world surface")]

wit_bindgen::generate!({
    path: "WIT_PATH",
    world: "plugin-world",
});

use exports::smith::plugin::plugin::{Guest, ToolDeclaration};
use exports::smith::plugin::provider::{
    CatalogSnapshot, DecodeStep, Guest as ProviderGuest, ProviderRequest, ProviderSettings,
    RequestTemplate, SettingsProvenance,
};
use exports::smith::plugin::registration::{Guest as RegistrationGuest, Registrations};

struct EchoPlugin;

impl RegistrationGuest for EchoPlugin {
    fn declare() -> Registrations {
        Registrations {
            credential_sources: Vec::new(),
            providers: Vec::new(),
            models: Vec::new(),
        }
    }
}

impl ProviderGuest for EchoPlugin {
    fn declare_settings() -> ProviderSettings {
        ProviderSettings {
            include_usage: false,
            subscription: false,
            provenance: SettingsProvenance::BuiltIn,
        }
    }

    fn validate_settings(_settings: ProviderSettings) -> Result<ProviderSettings, String> {
        Err("echo does not provide protocol settings".to_string())
    }

    fn build_request(
        _model: String,
        _request: ProviderRequest,
        _settings: ProviderSettings,
        _catalog: CatalogSnapshot,
    ) -> Result<RequestTemplate, String> {
        Err("echo does not provide a model codec".to_string())
    }

    fn decode_response(
        _state: Vec<u8>,
        _chunk: Vec<u8>,
        _finished: bool,
    ) -> Result<DecodeStep, String> {
        Err("echo does not provide a model decoder".to_string())
    }
}

impl Guest for EchoPlugin {
    fn declare_tools() -> Vec<ToolDeclaration> {
        vec![ToolDeclaration {
            name: "fixture".to_string(),
            description: "Echoes the input string back verbatim.".to_string(),
            input_schema_json: r#"{"type":"object","properties":{"mode":{"type":"string"}},"required":["mode"]}"#.to_string(),
        }]
    }

    fn invoke(_: String, input: String) -> Result<String, String> {
        if input.contains("siblings") {
            for _ in 0..2 {
                smith::plugin::composition::invoke("fixture:target/fixture", r#"{"mode":"child"}"#)?;
            }
            smith::plugin::tooling::write(&smith::plugin::tooling::FileWrite { path: "after.txt".into(), content: "siblings finished".into() })?;
            return Ok("siblings complete".into());
        }
        if input.contains("call-count") {
            for _ in 0..32 { let _ = smith::plugin::composition::invoke("fixture:target/fixture", r#"{"mode":"child-error"}"#); }
            return Ok("must not succeed".into());
        }
        if input.contains("conversion-budget") {
            use std::io::Write;
            let mut output = std::io::stdout().lock();
            for _ in 0..2050 { let _ = output.write_all(&[b'x'; 4096]); }
            return Ok("must not succeed".into());
        }
        if input.contains("child-error") { return Err("ordinary target error".into()); }
        if input.contains("external-cancel") {
            loop { core::hint::spin_loop(); }
        }
        if input.contains("spin") { loop { core::hint::spin_loop(); } }
        if input.contains("wasi-host") {
            use std::io::Write;
            smith::plugin::composition::invoke("fixture:target/fixture", r#"{"mode":"child"}"#)?;
            let bytes = vec![b'x'; 32 * 1024];
            let mut output = std::io::stdout().lock();
            for _ in 0..1024 { output.write_all(&bytes).map_err(|error| error.to_string())?; }
            smith::plugin::tooling::write(&smith::plugin::tooling::FileWrite { path: "after.txt".into(), content: "must not run".into() })?;
            return Ok("must not succeed".into());
        }
        if input.contains("output-budget") { return Ok("xx".into()); }
        if input.contains("overflow") { return Ok("x".repeat(1024 * 1024)); }
        if input.contains("hop") { return smith::plugin::composition::invoke("fixture:b/fixture", r#"{"mode":"reentry"}"#); }
        if input.contains("child") {
            smith::plugin::tooling::write(&smith::plugin::tooling::FileWrite {
                path: if input.contains("escape") { "../B/denied.txt" } else { "written.txt" }.into(),
                content: "child committed".into(),
            })?;
            return Ok("child complete".into());
        }
        let target = if input.contains("reentry") { "fixture:a/fixture" } else { "fixture:target/fixture" };
        let arguments = if input.contains("ordinary") { r#"{"mode":"child-error"}"# }
            else if input.contains("invalid") { "{}" }
            else if input.contains("escape") { r#"{"mode":"child-escape"}"# }
            else { r#"{"mode":"child"}"# };
        let result = smith::plugin::composition::invoke(target, arguments);
        if input.contains("fanout") { for _ in 0..32 { let _ = smith::plugin::composition::invoke(target, arguments); } }
        if input.contains("catch") { return Ok("caught ordinary guest error".into()); }
        if input.contains("parent-fail") { return Err("parent failed after child".into()); }
        result
    }
}

export!(EchoPlugin);