AI — `nestrs-ai`

[dependencies]
nestrs = { version = "1.7.1", features = ["ai"] } # implies resilience

use nestrs::ai::{
    AiModule, AiOptions, AiService, FakeModel, GenerateTextRequest, LanguageModel,
};
use serde_json::json;
use std::collections::HashMap;
use std::sync::Arc;

fn ai_module() -> nestrs::core::DynamicModule {
    let fake = FakeModel::new(vec![Ok(json!({ "text": "hello" }))]);
    let mut models = HashMap::new();
    models.insert("default".into(), Arc::new(fake) as Arc<dyn LanguageModel>);
    AiModule::register(AiOptions {
        models,
        defaults_timeout_ms: 5_000,
        max_steps: 5,
    })
}

let out = ai
    .generate_text(GenerateTextRequest {
        model: None, // "default"
        label: "support".into(),
        prompt: "Summarize the ticket".into(),
        instructions: Some("Be concise".into()),
        tools: vec![],
    })
    .await?;
println!("{}", out.text);

use nestrs::ai::GenerateObjectRequest;

#[derive(serde::Serialize, schemars::JsonSchema)]
struct TicketSummary {
    title: String,
    priority: u8,
}

let schema = schemars::schema_for!(TicketSummary);
let result = ai
    .generate_object(GenerateObjectRequest {
        model: None,
        label: "summary".into(),
        prompt: "Extract fields".into(),
        instructions: None,
        schema_name: "TicketSummary".into(),
        schema,
    })
    .await;

// Invalid JSON or missing required fields → AiError::Output (fail closed)

use nestrs::ai::{AgentFunction, AgentToolRegistry};
use serde_json::Value;
use std::sync::Arc;

let tools = AgentToolRegistry::new();
tools.register(AgentFunction {
    name: "lookup_order".into(),
    description: "Fetch an order by id".into(),
    handler: Arc::new(|args: Value| {
        Box::pin(async move {
            // Enforce caller authz here (Ability / guards) — never trust the model alone
            Ok(args)
        })
    }),
});

let ai = AiService::new(options).with_tools(tools);

#[async_trait::async_trait]
impl LanguageModel for MyOpenAiCompat {
    async fn call(&self, request: ModelCall) -> Result<ModelResponse, AiError> {
        // HTTP to OpenAI-compatible endpoint (feature `http` helpers optional)
        todo!()
    }
}