Native Tool Server

[package]
name = "pricing-tools"
version = "0.1.0"
edition = "2021"
default-run = "pricing-tools"

[workspace]

[dependencies]
chio-core = { package = "chio-core-types", git = "https://github.com/backbay-labs/chio", rev = "1346840e1192b5d6baf581c447cd37550e5c0144" }
chio-kernel = { git = "https://github.com/backbay-labs/chio", rev = "1346840e1192b5d6baf581c447cd37550e5c0144" }
chio-manifest = { git = "https://github.com/backbay-labs/chio", rev = "1346840e1192b5d6baf581c447cd37550e5c0144" }
chio-mcp-adapter = { git = "https://github.com/backbay-labs/chio", rev = "1346840e1192b5d6baf581c447cd37550e5c0144" }
chio-store-sqlite = { git = "https://github.com/backbay-labs/chio", rev = "1346840e1192b5d6baf581c447cd37550e5c0144" }

use chio_mcp_adapter::native::NativeTool;

let quote_tool = NativeTool::new(
    "quote",
    "Quote a SKU at a discount, rounded half up to the cent",
    serde_json::json!({
        "type": "object",
        "properties": {
            "sku": { "type": "string", "description": "A Larkfield SKU, such as sku-118" },
            "percent": { "type": "number", "minimum": 0, "maximum": 100 }
        },
        "required": ["sku", "percent"]
    }),
);

let quote_tool = NativeTool::new(
    "quote",
    "Quote a SKU at a discount, rounded half up to the cent",
    serde_json::json!({
        "type": "object",
        "properties": {
            "sku": { "type": "string" },
            "percent": { "type": "number", "minimum": 0, "maximum": 100 }
        },
        "required": ["sku", "percent"]
    }),
)
.output_schema(serde_json::json!({
    "type": "object",
    "properties": {
        "sku": { "type": "string" },
        "price": { "type": "string" },
        "currency": { "type": "string" }
    }
}))
.read_only()
.per_invocation_price(1, "USD")
.latency_hint(chio_manifest::LatencyHint::Instant);

use chio_mcp_adapter::native::NativeChioServiceBuilder;

NativeChioServiceBuilder::new("pricing", public_key_hex)
    .server_name("Larkfield pricing")
    .server_version("1.0.0")
    .server_description("Quotes and refunds on Larkfield's price table")

.tool(
    quote_tool,
    |arguments| {
        let sku = arguments
            .get("sku")
            .and_then(|value| value.as_str())
            .ok_or_else(|| {
                KernelError::RequestIncomplete("quote requires string field sku".to_string())
            })?;
        let percent = arguments
            .get("percent")
            .and_then(|value| value.as_f64())
            .filter(|percent| (0.0..=100.0).contains(percent))
            .ok_or_else(|| {
                KernelError::RequestIncomplete("percent must be between 0 and 100".to_string())
            })?;
        Ok(serde_json::json!({ "sku": sku, "percent": percent, "price": price(sku, percent)? }))
    },
)

use chio_core::ResourceContent;
use chio_mcp_adapter::native::NativeResource;

.static_resource(
    NativeResource::new("memory://pricing/price-list", "Larkfield price list")
        .description("List prices in USD, by SKU")
        .mime_type("text/csv"),
    vec![ResourceContent {
        uri: "memory://pricing/price-list".to_string(),
        mime_type: Some("text/csv".to_string()),
        text: Some("sku,list\nsku-118,24.00\nsku-204,58.00\nsku-301,140.00\n".to_string()),
        blob: None,
        annotations: None,
    }],
)

use chio_core::{PromptMessage, PromptResult};
use chio_mcp_adapter::native::NativePrompt;

.static_prompt(
    NativePrompt::new("draft_quote_email")
        .description("Asks for a short email that presents a quote to a customer"),
    PromptResult {
        description: Some("Quote email prompt".to_string()),
        messages: vec![PromptMessage {
            role: "user".to_string(),
            content: serde_json::json!({
                "type": "text",
                "text": "Write a two-sentence email presenting this quote to Priya Raman at Harbor Goods."
            }),
        }],
    },
)

let service = builder.build().expect("valid manifest");

use chio_kernel::KernelError;
use chio_mcp_adapter::native::{NativeChioService, NativeChioServiceBuilder, NativeTool};
use serde_json::{json, Value};

/// Larkfield list prices in cents, as main holds them after the Quickstart.
const PRICES: [(&str, i64); 3] = [("sku-118", 2400), ("sku-204", 5800), ("sku-301", 14000)];
/// Larkfield's one open order: its SKU and the amount paid, in cents.
const ORDERS: [(&str, &str, i64); 1] = [("order-77", "sku-204", 5800)];

pub fn build(public_key: String) -> anyhow::Result<NativeChioService> {
    Ok(NativeChioServiceBuilder::new("pricing", public_key)
        .server_name("Larkfield pricing")
        .server_version("1.0.0")
        .tool(
            NativeTool::new(
                "quote",
                "Quote a SKU at a discount, rounded half up to the cent",
                json!({
                    "type": "object",
                    "properties": {"sku": {"type": "string"}, "percent": {"type": "number"}},
                    "required": ["sku", "percent"]
                }),
            )
            .read_only(),
            |arguments| {
                let sku = text(&arguments, "sku")?;
                let percent = arguments
                    .get("percent")
                    .and_then(Value::as_f64)
                    .filter(|percent| (0.0..=100.0).contains(percent))
                    .ok_or_else(|| incomplete("percent must be between 0 and 100"))?;
                let cents = PRICES
                    .iter()
                    .find(|(id, _)| *id == sku)
                    .map(|(_, cents)| *cents)
                    .ok_or_else(|| incomplete("unknown sku"))?;
                // Basis points keep the arithmetic exact; the last step rounds half up.
                let basis = (percent * 100.0).round() as i64;
                let price = (cents * (10_000 - basis) + 5_000) / 10_000;
                Ok(json!({"sku": sku, "percent": percent, "price": usd(price), "currency": "USD"}))
            },
        )
        .tool(
            NativeTool::new(
                "refund",
                "Refund an order in full",
                json!({
                    "type": "object",
                    "properties": {"order": {"type": "string"}},
                    "required": ["order"]
                }),
            ),
            |arguments| {
                let order = text(&arguments, "order")?;
                let (id, _, paid) = ORDERS
                    .iter()
                    .find(|(id, _, _)| *id == order)
                    .ok_or_else(|| incomplete("unknown order"))?;
                Ok(json!({"order": id, "refunded": usd(*paid), "currency": "USD"}))
            },
        )
        .build()?)
}

fn text<'a>(arguments: &'a Value, field: &str) -> Result<&'a str, KernelError> {
    arguments
        .get(field)
        .and_then(Value::as_str)
        .ok_or_else(|| incomplete(&format!("{field} must be a string")))
}

fn incomplete(message: &str) -> KernelError {
    KernelError::RequestIncomplete(message.into())
}

fn usd(cents: i64) -> String {
    format!("{}.{:02}", cents / 100, cents % 100)
}

NativeTool::new("lookup", "Look up a record", schema)
    .flat_price(500, "USD")

NativeTool::new("quote", "Quote a SKU at a discount", schema)
    .per_invocation_price(1, "USD")   // USD 0.01 per quote

NativeTool::new("tokenize", "Tokenize text", schema)
    .per_unit_price(2, "USD", "1k_tokens")

NativeTool::new("search", "Search documents", schema)
    .hybrid_price(25, 10, "USD", "document")
    // USD minor units: 25 cents base + 10 cents per document

use chio_core::crypto::Keypair;

let server_kp = Keypair::generate();
let service = crate::service::build(server_kp.public_key().to_hex())?;

// sign_manifest returns a SignedManifest bundling the manifest, its Ed25519
// signature, and the signer's public key. There is no separate hash field.
let signed = chio_manifest::sign_manifest(service.manifest(), &server_kp)?;

// signed.manifest is the ToolManifest; signed.signature is the Ed25519
// signature; signed.signer_key is the public key it was signed with.
println!("signed by: {}", signed.signer_key.to_hex());

pub struct ToolManifest {
    /// Schema version. Must equal [`TOOL_MANIFEST_SCHEMA`].
    pub schema: String,

    /// The server's unique identifier.
    pub server_id: chio_core::ServerId,

    /// Human-readable server name.
    pub name: String,

    /// Server description.
    pub description: Option<String>,

    /// Semantic version of this tool server.
    pub version: String,

    /// The tools this server provides.
    pub tools: Vec<ToolDefinition>,

    /// Provider-native server tools this manifest explicitly allows.
    ///
    /// Anthropic server tools are larger trust-boundary surfaces than regular
    /// client-hosted tools. They default to deny unless the manifest lists the
    /// stable logical tool name here.
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub server_tools: Vec<ServerTool>,

    /// Permissions this server requires from the host environment
    /// (filesystem paths, network access, environment variables, etc.).
    pub required_permissions: Option<RequiredPermissions>,

    /// Hex-encoded Ed25519 public key of this tool server.
    pub public_key: String,
}