Add -g for specifying a GBNF grammar. (#2)

Author: oleksandrvoyager

Cargo.lock

@@ -29,7 +29,6 @@ tracing = ["asimov-module/tracing", "clientele?/tracing"]
 
 [dependencies]
 asimov-module = { version = "25.0.0-dev.21", default-features = false }
-bon = { version = "3.7.2", default-features = false, features = ["alloc"] }
 serde = { version = "1.0", default-features = false, features = ["alloc"] }
 serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
 ureq = { version = "3.1", features = ["json"] }

Cargo.toml

@@ -59,6 +59,19 @@ export ASIMOV_LLAMACPP_MODEL="TinyLlama-1.1B-Chat-v1.0"
 echo "Why is the sky blue?" | asimov-llamacpp-prompter
 ```
 
+### 🧪 Simple GBNF example
+
+1) Create a tiny grammar that only allows `ok`:
+```bnf
+# only_ok.gbnf
+root ::= "ok" "\n"
+```
+2) Run the prompter with the grammar:
+```bash
+echo "Say anything." | asimov-llamacpp-prompter -g only_ok.gbnf
+# => ok
+```
+
 ## 👨‍💻 Development
 
 ```bash

README.md

@@ -7,28 +7,33 @@ use asimov_module::{prelude::*, tracing};
 use core::error::Error;
 use serde_json::{Value, json};
 
-#[derive(Clone, Debug, bon::Builder)]
-#[builder(on(String, into))]
+#[derive(Clone, Debug)]
 pub struct Options {
     /// Base URL of the llama.cpp server (e.g. http://localhost:8080)
     pub endpoint: String,
-
     /// Model identifier (e.g. "llama3")
     pub model: String,
+    /// Optional raw GBNF grammar text to constrain decoding
+    pub grammar: Option<String>,
 }
 
-/// Generate a response using llama.cpp’s OpenAI-compatible endpoint.
-/// Example: POST /v1/chat/completions
+/// POST /v1/chat/completions with optional GBNF grammar
 pub fn generate(input: impl AsRef<str>, options: &Options) -> Result<Vec<String>, Box<dyn Error>> {
     const UA: &str = "asimov-llamacpp-module";
     const CT_JSON: &str = "application/json";
 
-    let req = json!({
+    let mut req = json!({
         "model": options.model,
         "messages": [{ "role": "user", "content": input.as_ref() }],
         "stream": false
     });
 
+    if let Some(g) = &options.grammar {
+        if let Value::Object(obj) = &mut req {
+            obj.insert("grammar".into(), Value::String(g.clone()));
+        }
+    }
+
     let agent = ureq::Agent::config_builder()
         .http_status_as_error(false)
         .user_agent(UA)

src/lib.rs

@@ -15,10 +15,19 @@ struct Options {
     #[clap(flatten)]
     flags: StandardOptions,
 
-    #[clap(long, short = 'm')]
+    #[clap(long, short)]
     model: Option<String>,
 
+    /// Path to a GBNF grammar file (used to constrain decoding)
+    #[clap(long, short)]
+    grammar: Option<String>,
+
+    /// Input file (defaults to STDIN)
+    #[clap(long, short)]
     input: Option<String>,
+
+    /// Output file (defaults to STDOUT)
+    #[clap(long, short)]
     output: Option<String>,
 }
 
@@ -88,10 +97,23 @@ pub fn main() -> Result<SysexitsError, Box<dyn Error>> {
         Box::new(std::io::stdout().lock())
     };
 
-    let options = asimov_llamacpp_module::Options::builder()
-        .endpoint(endpoint)
-        .model(model)
-        .build();
+    let grammar: Option<String> = if let Some(path) = options.grammar {
+        match std::fs::read_to_string(&path) {
+            Ok(s) => Some(s),
+            Err(e) => {
+                tracing::error!("unable to read grammar file '{}': {e}", path);
+                return Ok(EX_NOINPUT);
+            },
+        }
+    } else {
+        None
+    };
+
+    let options = asimov_llamacpp_module::Options {
+        endpoint,
+        model,
+        grammar,
+    };
 
     let response = asimov_llamacpp_module::generate(&input, &options)?;