use super::{KeyPoint, Sentiment, SentimentAnalyzer, Topic, TopicExtractor};
use crate::models::ChatSession;
use serde::{Deserialize, Serialize};
use std::fmt;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum AnalysisSource {
Model,
Heuristic,
}
impl fmt::Display for AnalysisSource {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
AnalysisSource::Model => write!(f, "model"),
AnalysisSource::Heuristic => write!(f, "heuristic"),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SessionAnalysis {
pub source: AnalysisSource,
pub summary: String,
pub topics: Vec<Topic>,
pub sentiment: Sentiment,
pub key_points: Vec<KeyPoint>,
}
#[derive(Debug)]
pub enum AnalysisError {
NoApiKey,
Http(String),
BadResponse(String),
}
impl fmt::Display for AnalysisError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
AnalysisError::NoApiKey => write!(f, "no OpenAI API key configured"),
AnalysisError::Http(e) => write!(f, "analysis request failed: {}", e),
AnalysisError::BadResponse(e) => write!(f, "unusable model response: {}", e),
}
}
}
impl std::error::Error for AnalysisError {}
const MAX_CHARS: usize = 24_000;
const SYSTEM_PROMPT: &str = "You analyze developer chat sessions. Reply with JSON only, matching:
{\"summary\": string,
\"topics\": [{\"name\": string, \"confidence\": number 0-1, \"keywords\": [string]}],
\"sentiment\": {\"score\": number -1 to 1, \"label\": \"positive\"|\"neutral\"|\"negative\", \"confidence\": number 0-1},
\"keyPoints\": [{\"summary\": string, \"importance\": number 0-1, \"category\": string}]}
Report topics actually discussed, not every technology mentioned in passing.";
#[derive(Debug, Clone)]
pub struct ModelAnalyzer {
api_key: String,
model: String,
base_url: String,
client: reqwest::Client,
}
impl ModelAnalyzer {
pub fn new(api_key: impl Into<String>) -> Self {
Self {
api_key: api_key.into(),
model: "gpt-4o-mini".to_string(),
base_url: "https://api.openai.com/v1".to_string(),
client: reqwest::Client::new(),
}
}
pub fn from_env() -> Option<Self> {
let key = std::env::var("OPENAI_API_KEY").ok()?;
if key.trim().is_empty() {
return None;
}
let mut analyzer = Self::new(key);
if let Ok(url) = std::env::var("OPENAI_BASE_URL") {
if !url.trim().is_empty() {
analyzer = analyzer.with_base_url(url.trim_end_matches('/').to_string());
}
}
if let Ok(model) = std::env::var("IRONBRIDGE_ANALYSIS_MODEL") {
if !model.trim().is_empty() {
analyzer = analyzer.with_model(model);
}
}
Some(analyzer)
}
pub fn with_model(mut self, model: impl Into<String>) -> Self {
self.model = model.into();
self
}
pub fn with_base_url(mut self, base_url: impl Into<String>) -> Self {
self.base_url = base_url.into();
self
}
pub async fn analyze(&self, session: &ChatSession) -> Result<SessionAnalysis, AnalysisError> {
if self.api_key.trim().is_empty() {
return Err(AnalysisError::NoApiKey);
}
let transcript = truncate_transcript(&session.collect_all_text());
if transcript.trim().is_empty() {
return Err(AnalysisError::BadResponse(
"session has no text to analyze".to_string(),
));
}
let body = serde_json::json!({
"model": self.model,
"temperature": 0,
"response_format": { "type": "json_object" },
"messages": [
{ "role": "system", "content": SYSTEM_PROMPT },
{ "role": "user", "content": transcript },
],
});
let response = self
.client
.post(format!("{}/chat/completions", self.base_url))
.bearer_auth(&self.api_key)
.json(&body)
.send()
.await
.map_err(|e| AnalysisError::Http(e.to_string()))?;
let status = response.status();
let text = response
.text()
.await
.map_err(|e| AnalysisError::Http(e.to_string()))?;
if !status.is_success() {
return Err(AnalysisError::Http(format!("HTTP {}: {}", status, text)));
}
parse_completion(&text)
}
}
fn truncate_transcript(text: &str) -> String {
if text.len() <= MAX_CHARS {
return text.to_string();
}
text.chars().take(MAX_CHARS).collect()
}
fn parse_completion(raw: &str) -> Result<SessionAnalysis, AnalysisError> {
#[derive(Deserialize)]
struct Message {
content: Option<String>,
}
#[derive(Deserialize)]
struct Choice {
message: Message,
}
#[derive(Deserialize)]
struct Completion {
choices: Vec<Choice>,
}
let completion: Completion = serde_json::from_str(raw)
.map_err(|e| AnalysisError::BadResponse(format!("not a completion: {}", e)))?;
let content = completion
.choices
.first()
.and_then(|c| c.message.content.as_deref())
.ok_or_else(|| AnalysisError::BadResponse("no choices returned".to_string()))?;
parse_analysis(content)
}
fn parse_analysis(content: &str) -> Result<SessionAnalysis, AnalysisError> {
#[derive(Deserialize)]
struct RawTopic {
name: String,
#[serde(default)]
confidence: f32,
#[serde(default)]
keywords: Vec<String>,
}
#[derive(Deserialize)]
struct RawSentiment {
#[serde(default)]
score: f32,
#[serde(default)]
label: String,
#[serde(default)]
confidence: f32,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct RawKeyPoint {
summary: String,
#[serde(default)]
importance: f32,
#[serde(default)]
category: String,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct RawAnalysis {
#[serde(default)]
summary: String,
#[serde(default)]
topics: Vec<RawTopic>,
sentiment: Option<RawSentiment>,
#[serde(default)]
key_points: Vec<RawKeyPoint>,
}
let cleaned = strip_code_fence(content);
let raw: RawAnalysis = serde_json::from_str(cleaned).map_err(|e| {
AnalysisError::BadResponse(format!("{}: {}", e, truncate_for_error(cleaned)))
})?;
let sentiment = raw
.sentiment
.map(|s| Sentiment {
score: s.score.clamp(-1.0, 1.0),
label: if s.label.is_empty() {
"neutral".to_string()
} else {
s.label
},
confidence: s.confidence.clamp(0.0, 1.0),
})
.unwrap_or_else(|| Sentiment {
score: 0.0,
label: "neutral".to_string(),
confidence: 0.0,
});
Ok(SessionAnalysis {
source: AnalysisSource::Model,
summary: raw.summary,
topics: raw
.topics
.into_iter()
.map(|t| Topic {
name: t.name,
confidence: t.confidence.clamp(0.0, 1.0),
keywords: t.keywords,
})
.collect(),
sentiment,
key_points: raw
.key_points
.into_iter()
.map(|k| KeyPoint {
summary: k.summary,
importance: k.importance.clamp(0.0, 1.0),
category: if k.category.is_empty() {
"general".to_string()
} else {
k.category
},
})
.collect(),
})
}
fn strip_code_fence(content: &str) -> &str {
let trimmed = content.trim();
let Some(rest) = trimmed.strip_prefix("```") else {
return trimmed;
};
let rest = rest.strip_prefix("json").unwrap_or(rest);
rest.trim_start_matches('\n').trim_end_matches("```").trim()
}
fn truncate_for_error(s: &str) -> String {
s.chars().take(200).collect()
}
pub struct Analyzer {
model: Option<ModelAnalyzer>,
}
impl Analyzer {
pub fn from_env() -> Self {
Self {
model: ModelAnalyzer::from_env(),
}
}
pub fn offline() -> Self {
Self { model: None }
}
pub fn with_model(model: ModelAnalyzer) -> Self {
Self { model: Some(model) }
}
pub fn is_model_backed(&self) -> bool {
self.model.is_some()
}
pub async fn analyze(&self, session: &ChatSession) -> SessionAnalysis {
if let Some(model) = &self.model {
match model.analyze(session).await {
Ok(analysis) => return analysis,
Err(e) => {
eprintln!("[WARN] model analysis failed, using heuristics: {}", e);
}
}
}
heuristic_analysis(session)
}
pub async fn analyze_with_model(
&self,
session: &ChatSession,
) -> Result<SessionAnalysis, AnalysisError> {
match &self.model {
Some(model) => model.analyze(session).await,
None => Err(AnalysisError::NoApiKey),
}
}
}
impl Default for Analyzer {
fn default() -> Self {
Self::from_env()
}
}
pub fn heuristic_analysis(session: &ChatSession) -> SessionAnalysis {
let topics = TopicExtractor::new().extract(session);
let sentiment = SentimentAnalyzer::new().analyze(session);
SessionAnalysis {
source: AnalysisSource::Heuristic,
summary: String::new(),
topics,
sentiment,
key_points: Vec::new(),
}
}
#[cfg(test)]
mod tests {
use super::*;
fn empty_session() -> ChatSession {
serde_json::from_str("{}").unwrap()
}
const GOOD: &str = r#"{
"summary": "Debugging a borrow checker error in an async handler.",
"topics": [
{"name": "rust async", "confidence": 0.9, "keywords": ["tokio", "await"]},
{"name": "error handling", "confidence": 0.4, "keywords": ["Result"]}
],
"sentiment": {"score": -0.2, "label": "neutral", "confidence": 0.7},
"keyPoints": [
{"summary": "Lifetime needed to outlive the spawned task.", "importance": 0.9, "category": "root cause"}
]
}"#;
#[test]
fn parses_a_well_formed_analysis() {
let a = parse_analysis(GOOD).unwrap();
assert_eq!(a.source, AnalysisSource::Model);
assert_eq!(a.topics.len(), 2);
assert_eq!(a.topics[0].name, "rust async");
assert_eq!(a.key_points.len(), 1);
assert_eq!(a.sentiment.label, "neutral");
}
#[test]
fn out_of_range_numbers_are_clamped() {
let json = r#"{"summary":"s","topics":[{"name":"t","confidence":5.0,"keywords":[]}],
"sentiment":{"score":-9.0,"label":"negative","confidence":3.0},
"keyPoints":[{"summary":"k","importance":7.0,"category":"c"}]}"#;
let a = parse_analysis(json).unwrap();
assert_eq!(a.topics[0].confidence, 1.0);
assert_eq!(a.sentiment.score, -1.0);
assert_eq!(a.sentiment.confidence, 1.0);
assert_eq!(a.key_points[0].importance, 1.0);
}
#[test]
fn missing_sentiment_defaults_to_neutral_with_no_confidence() {
let a = parse_analysis(r#"{"summary":"s","topics":[],"keyPoints":[]}"#).unwrap();
assert_eq!(a.sentiment.label, "neutral");
assert_eq!(a.sentiment.confidence, 0.0);
}
#[test]
fn a_fenced_reply_still_parses() {
let fenced = format!("```json\n{}\n```", GOOD);
let a = parse_analysis(&fenced).unwrap();
assert_eq!(a.topics.len(), 2);
}
#[test]
fn a_bare_fence_without_a_language_tag_parses() {
let fenced = format!("```\n{}\n```", GOOD);
assert!(parse_analysis(&fenced).is_ok());
}
#[test]
fn prose_instead_of_json_is_an_error_not_an_empty_analysis() {
let err = parse_analysis("I could not analyze that.").unwrap_err();
assert!(matches!(err, AnalysisError::BadResponse(_)));
}
#[test]
fn completion_envelope_is_unwrapped() {
let envelope = serde_json::json!({
"choices": [{ "message": { "role": "assistant", "content": GOOD } }]
})
.to_string();
let a = parse_completion(&envelope).unwrap();
assert_eq!(a.topics.len(), 2);
}
#[test]
fn an_empty_choices_list_is_an_error() {
let envelope = r#"{"choices":[]}"#;
assert!(matches!(
parse_completion(envelope).unwrap_err(),
AnalysisError::BadResponse(_)
));
}
#[test]
fn truncation_does_not_split_a_multibyte_character() {
let text = "あ".repeat(MAX_CHARS + 100);
let out = truncate_transcript(&text);
assert_eq!(out.chars().count(), MAX_CHARS);
}
#[test]
fn short_text_is_returned_unchanged() {
assert_eq!(truncate_transcript("hello"), "hello");
}
#[tokio::test]
async fn an_analyzer_with_no_key_reports_heuristic_source() {
let session = empty_session();
let analyzer = Analyzer::offline();
assert!(!analyzer.is_model_backed());
assert_eq!(
analyzer.analyze(&session).await.source,
AnalysisSource::Heuristic
);
}
#[tokio::test]
async fn strict_mode_errors_rather_than_falling_back() {
let session = empty_session();
let err = Analyzer::offline()
.analyze_with_model(&session)
.await
.unwrap_err();
assert!(matches!(err, AnalysisError::NoApiKey));
}
#[tokio::test]
async fn a_blank_key_is_rejected_before_any_request() {
let session = empty_session();
let err = ModelAnalyzer::new(" ")
.analyze(&session)
.await
.unwrap_err();
assert!(matches!(err, AnalysisError::NoApiKey));
}
async fn one_shot_server(status_line: &'static str, body: String) -> String {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move {
let (mut socket, _) = listener.accept().await.unwrap();
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let mut buf = [0u8; 8192];
let _ = socket.read(&mut buf).await;
let response = format!(
"HTTP/1.1 {}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
status_line,
body.len(),
body
);
let _ = socket.write_all(response.as_bytes()).await;
let _ = socket.flush().await;
});
format!("http://{}", addr)
}
fn session_with_text(text: &str) -> ChatSession {
serde_json::from_value(serde_json::json!({
"requests": [{ "message": { "text": text } }]
}))
.unwrap()
}
#[tokio::test]
async fn analyze_round_trips_against_a_real_http_server() {
let envelope = serde_json::json!({
"choices": [{ "message": { "content": GOOD } }]
})
.to_string();
let url = one_shot_server("200 OK", envelope).await;
let analyzer = ModelAnalyzer::new("test-key").with_base_url(url);
let analysis = analyzer
.analyze(&session_with_text("why does this borrow fail"))
.await
.unwrap();
assert_eq!(analysis.source, AnalysisSource::Model);
assert_eq!(analysis.topics.len(), 2);
assert_eq!(analysis.key_points[0].category, "root cause");
}
#[tokio::test]
async fn a_non_2xx_reply_is_an_http_error_carrying_the_body() {
let url = one_shot_server("429 Too Many Requests", r#"{"error":"slow down"}"#.into()).await;
let err = ModelAnalyzer::new("test-key")
.with_base_url(url)
.analyze(&session_with_text("hello"))
.await
.unwrap_err();
match err {
AnalysisError::Http(msg) => {
assert!(msg.contains("429"), "status should survive: {}", msg);
assert!(msg.contains("slow down"), "body should survive: {}", msg);
}
other => panic!("expected Http, got {:?}", other),
}
}
#[tokio::test]
async fn an_empty_session_is_rejected_before_spending_a_request() {
let err = ModelAnalyzer::new("test-key")
.with_base_url("http://127.0.0.1:1".to_string())
.analyze(&empty_session())
.await
.unwrap_err();
assert!(matches!(err, AnalysisError::BadResponse(_)));
}
#[tokio::test]
async fn the_fallback_survives_an_unreachable_model() {
let analyzer = Analyzer::with_model(
ModelAnalyzer::new("test-key").with_base_url("http://127.0.0.1:1".to_string()),
);
let analysis = analyzer
.analyze(&session_with_text("rust cargo build"))
.await;
assert_eq!(analysis.source, AnalysisSource::Heuristic);
}
#[test]
fn a_trailing_slash_on_the_base_url_does_not_double_up() {
let a = ModelAnalyzer::new("k").with_base_url("http://host/v1/".trim_end_matches('/'));
assert_eq!(a.base_url, "http://host/v1");
}
#[test]
fn heuristic_analysis_does_not_fabricate_a_summary() {
let a = heuristic_analysis(&empty_session());
assert!(a.summary.is_empty());
assert_eq!(a.source, AnalysisSource::Heuristic);
}
}