Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

smith-harness/tests/fixtures/registered-provider.rs

Raw
//! Registered provider fixture (`SMH-SPEC-SPEC0001`).
wit_bindgen::generate!({ path: "wit", world: "plugin-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![CredentialSource {
                id: "fixture-key".into(),
            }],
            providers: vec![ProviderContribution {
                id: "custom".into(),
                protocol: ProtocolBinding::OpenaiCompatible,
                credential_source_id: "fixture-key".into(),
            }],
            models: vec![ModelContribution {
                id: "fixture-model".into(),
                provider_id: "custom".into(),
            }],
        }
    }
}
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)),
            ],
        })
    }
}
export!(Plugin);