open-standards/mesh/mesh-rs/crates/mesh-openai/examples/serve.rs

//! Run the Mesh OpenAI-compatible reference server — a real
//! `/v1/chat/completions` endpoint any OpenAI client (curl, the SDKs, vLLM-style
//! tooling) can drive, returning energy-metered serving + a sealed receipt.
//!
//! ```text
//! cargo run --example serve --features server -- 127.0.0.1:8088 &
//! curl -s localhost:8088/v1/chat/completions \
//!   -d '{"model":"gpt-mini","messages":[{"role":"user","content":"hi"}],"max_tokens":8}'
//! ```

use std::net::TcpListener;

use ed25519_dalek::SigningKey;
use mesh_core::Mesh;
use mesh_engine::ReferenceEngine;
use mesh_meter::{Provenance, SteppingMeter};
use mesh_openai::{server, ChatBackend};
use mesh_router::BackendSpec;
use mesh_schema::Fidelity;

/// A trivial tokenizer bridge: bytes in, a deterministic note out. A real
/// deployment pairs the model's own tokenizer with the engine that serves it.
struct ByteBackend;
impl ChatBackend for ByteBackend {
    fn encode(&self, text: &str) -> Vec<u32> {
        text.bytes().map(u32::from).collect()
    }
    fn decode(&self, ids: &[u32]) -> String {
        format!("[mesh reference engine served {} tokens]", ids.len())
    }
}

fn main() -> std::io::Result<()> {
    let addr = std::env::args().nth(1).unwrap_or_else(|| "127.0.0.1:8088".to_string());
    let listener = TcpListener::bind(&addr)?;
    eprintln!("mesh OpenAI server: http://{addr}/v1/chat/completions");

    // A measured-grade meter (stepping, HwShunt) + the deterministic reference
    // engine, behind one steward-signed receipt chain.
    let meter = SteppingMeter::new("rapl", Provenance::HwShunt, 4_800_000);
    let sk = SigningKey::from_bytes(&[8u8; 32]);
    let mut mesh = Mesh::new(&meter, sk, "did:example:mesh-demo");
    mesh.register(
        BackendSpec::new("tiny", "ssm-1b", Fidelity::F2, 50_000),
        Box::new(ReferenceEngine::new("tiny", "ssm-1b", Fidelity::F2, 50_000, 32)),
    );

    server::run(&listener, &mut mesh, &ByteBackend, 100_000_000)
}