use std::collections::HashMap;
use std::sync::Arc;
use anyhow::{anyhow, Result};
use async_trait::async_trait;
use serde_json::Value;
use crate::domain::services::llm::chunker::{self, ChunkingConfig};
use crate::domain::services::llm::prompt_builder::{
build_prompt, parse_llm_response, FileTemplateLoader, TemplateLoaderTrait,
};
use crate::domain::services::llm::provenance;
use crate::domain::services::llm::{LLMServiceTrait, TokenUsage};
pub struct FluxweirLlmCarrier {
client: Arc<fluxweir::sdk::FluxweirClient>,
model: String,
templates: Arc<HashMap<String, String>>,
provenance_enabled: bool,
provenance_min_coverage: f64,
chunking: Option<ChunkingConfig>,
}
impl FluxweirLlmCarrier {
pub fn new(client: fluxweir::sdk::FluxweirClient, settings: &crate::config::Settings) -> Self {
let templates = FileTemplateLoader::default_path()
.load_templates()
.unwrap_or_default();
let chunking = if settings.llm.chunking.enabled {
Some(ChunkingConfig::from_settings(&settings.llm.chunking))
} else {
None
};
Self {
client: Arc::new(client),
model: settings
.llm
.model
.clone()
.unwrap_or_else(|| "auto".to_string()),
templates: Arc::new(templates),
provenance_enabled: settings.llm.provenance_enabled,
provenance_min_coverage: settings.llm.provenance_min_coverage,
chunking,
}
}
async fn chat_extract(
&self,
text: &str,
schema: &Value,
format: &str,
) -> Result<(Value, TokenUsage)> {
let template = self
.templates
.get(format)
.ok_or_else(|| {
anyhow!(
"no prompt template registered for format \"{format}\" \
(loaded from config/prompts.toml)"
)
})?
.clone();
let prompt = build_prompt(&template, text, schema)?;
let request = fluxweir::sdk::ChatRequest::new(&self.model, &prompt);
let response = self
.client
.chat(&request)
.await
.map_err(|e| anyhow!("fluxweir chat request failed: {e}"))?;
parse_chat_payload(
&response.content,
format,
response.usage.prompt_tokens,
response.usage.completion_tokens,
response.usage.total_tokens,
)
}
async fn extract_one_chunk(
client: &fluxweir::sdk::FluxweirClient,
model: &str,
templates: &HashMap<String, String>,
schema_json: &str,
format: &str,
chunk_text: &str,
) -> Result<(Value, TokenUsage)> {
let template = templates
.get(format)
.ok_or_else(|| anyhow!("no prompt template registered for format \"{format}\""))?;
let prompt = build_prompt(
template,
chunk_text,
&serde_json::from_str::<Value>(schema_json)?,
)?;
let response = client
.chat(&fluxweir::sdk::ChatRequest::new(model, &prompt))
.await
.map_err(|e| anyhow!("fluxweir chat request failed: {e}"))?;
parse_chat_payload(
&response.content,
format,
response.usage.prompt_tokens,
response.usage.completion_tokens,
response.usage.total_tokens,
)
}
async fn merge_chunk_results(
client: &fluxweir::sdk::FluxweirClient,
model: &str,
schema_json: &str,
format: &str,
merge_json: &str,
) -> Result<(Value, TokenUsage)> {
let prompt = merge_prompt(merge_json, schema_json);
let response = client
.chat(&fluxweir::sdk::ChatRequest::new(model, &prompt))
.await
.map_err(|e| anyhow!("fluxweir merge request failed: {e}"))?;
parse_chat_payload(
&response.content,
format,
response.usage.prompt_tokens,
response.usage.completion_tokens,
response.usage.total_tokens,
)
}
}
fn parse_chat_payload(
content: &str,
format: &str,
prompt_tokens: u64,
completion_tokens: u64,
total_tokens: u64,
) -> Result<(Value, TokenUsage)> {
let value = parse_llm_response(content, format).map_err(|e| {
let snippet: String = content.chars().take(500).collect();
anyhow!("llm response is not valid {format}: {e} — response snippet: {snippet}")
})?;
let usage = TokenUsage {
prompt_tokens: u32::try_from(prompt_tokens).unwrap_or(u32::MAX),
completion_tokens: u32::try_from(completion_tokens).unwrap_or(u32::MAX),
total_tokens: u32::try_from(total_tokens).unwrap_or(u32::MAX),
};
Ok((value, usage))
}
fn merge_prompt(merge_json: &str, schema_json: &str) -> String {
format!(
"You are merging partial JSON extraction results. \
Merge the following partial results into a single JSON object that is \
consistent with the schema. Resolve conflicts by preferring the more \
complete value. Respond with ONLY the merged JSON.\n\n\
Schema:\n{schema_json}\n\nPartial results:\n{merge_json}"
)
}
#[async_trait]
impl LLMServiceTrait for FluxweirLlmCarrier {
async fn extract_data(
&self,
text: &str,
schema: &Value,
format: &str,
) -> Result<(Value, TokenUsage), anyhow::Error> {
self.chat_extract(text, schema, format).await
}
async fn extract_data_chunked(
&self,
text: &str,
schema: &Value,
format: &str,
) -> Result<(Value, TokenUsage), anyhow::Error> {
let Some(cfg) = self.chunking.clone() else {
return self.extract_data(text, schema, format).await;
};
let client = self.client.clone();
let model = self.model.clone();
let templates = self.templates.clone();
let schema_json = serde_json::to_string(schema)?;
let format_owned = format.to_string();
let extract_client = client.clone();
let extract_model = model.clone();
let extract_templates = templates.clone();
let extract_schema = schema_json.clone();
let extract_format = format_owned.clone();
let extract_one = move |chunk_text: String| {
let client = extract_client.clone();
let model = extract_model.clone();
let templates = extract_templates.clone();
let schema_json = extract_schema.clone();
let format = extract_format.clone();
async move {
Self::extract_one_chunk(
&client,
&model,
&templates,
&schema_json,
&format,
&chunk_text,
)
.await
}
};
let merge_client = client;
let merge_model = model;
let merge_schema = schema_json;
let merge_format = format_owned;
let merge_call = move |merge_json: String| {
let client = merge_client.clone();
let model = merge_model.clone();
let schema_json = merge_schema.clone();
let format = merge_format.clone();
async move {
Self::merge_chunk_results(&client, &model, &schema_json, &format, &merge_json).await
}
};
chunker::extract_chunked(text, schema, &cfg, extract_one, merge_call).await
}
async fn extract_data_with_provenance(
&self,
text: &str,
schema: &Value,
format: &str,
) -> Result<(Value, Option<Value>, TokenUsage), anyhow::Error> {
let (mut value, usage) = self.extract_data(text, schema, format).await?;
if !self.provenance_enabled {
return Ok((value, None, usage));
}
let prov = provenance::provenance_map(text, &value, self.provenance_min_coverage);
provenance::attach_provenance(&mut value, &prov);
Ok((value, Some(prov), usage))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parse_chat_payload_success_maps_usage() {
let (value, usage) =
parse_chat_payload(r#"{"name":"x"}"#, "json", 11, 7, 18).expect("parse ok");
assert_eq!(value["name"], "x");
assert_eq!(usage.prompt_tokens, 11);
assert_eq!(usage.completion_tokens, 7);
assert_eq!(usage.total_tokens, 18);
}
#[test]
fn parse_chat_payload_non_json_errors_with_snippet() {
let body = "not json at all ".repeat(80);
let err = parse_chat_payload(&body, "json", 1, 1, 2).expect_err("must error");
let rendered = format!("{err:#}");
assert!(rendered.contains("not valid json"), "{rendered}");
assert!(rendered.contains("response snippet"), "{rendered}");
}
#[test]
fn parse_chat_payload_zero_usage_is_legal() {
let (value, usage) =
parse_chat_payload(r#"{"name":"x"}"#, "json", 0, 0, 0).expect("parse ok");
assert_eq!(value["name"], "x");
assert_eq!(usage, TokenUsage::default());
}
#[test]
fn merge_prompt_carries_schema_and_results() {
let prompt = merge_prompt(r#"[{"a":1}]"#, r#"{"type":"object"}"#);
assert!(prompt.contains(r#"{"type":"object"}"#));
assert!(prompt.contains(r#"[{"a":1}]"#));
}
#[test]
fn parse_chat_payload_saturates_huge_usage() {
let (_, usage) = parse_chat_payload(r#"{}"#, "json", u64::MAX, 0, 0).expect("parse ok");
assert_eq!(usage.prompt_tokens, u32::MAX);
}
}