c2bd3c08e1
load_history now groups preceding tool_call + tool_result scaffolding
under each assistant reply as `tools: [{name, arguments, result}]`.
Result bodies over 2000 chars are truncated for payload size with a
`result_truncated` flag; the full value remains in training_messages.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
829 lines
30 KiB
Rust
829 lines
30 KiB
Rust
use actix_web::{HttpRequest, HttpResponse, Responder, delete, get, post, web};
|
|
use opentelemetry::KeyValue;
|
|
use opentelemetry::trace::{Span, Status, Tracer};
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use crate::ai::insight_chat::ChatTurnRequest;
|
|
use crate::ai::{InsightGenerator, ModelCapabilities, OllamaClient};
|
|
use crate::data::Claims;
|
|
use crate::database::{ExifDao, InsightDao};
|
|
use crate::libraries;
|
|
use crate::otel::{extract_context_from_request, global_tracer};
|
|
use crate::state::AppState;
|
|
use crate::utils::normalize_path;
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct GeneratePhotoInsightRequest {
|
|
pub file_path: String,
|
|
#[serde(default)]
|
|
pub model: Option<String>,
|
|
#[serde(default)]
|
|
pub system_prompt: Option<String>,
|
|
#[serde(default)]
|
|
pub num_ctx: Option<i32>,
|
|
#[serde(default)]
|
|
pub temperature: Option<f32>,
|
|
#[serde(default)]
|
|
pub top_p: Option<f32>,
|
|
#[serde(default)]
|
|
pub top_k: Option<i32>,
|
|
#[serde(default)]
|
|
pub min_p: Option<f32>,
|
|
/// `"local"` (default, Ollama with images) | `"hybrid"` (local vision +
|
|
/// OpenRouter chat). Only respected by the agentic endpoint.
|
|
#[serde(default)]
|
|
pub backend: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct GetPhotoInsightQuery {
|
|
pub path: String,
|
|
/// Library context for this lookup. Used to pick the right content
|
|
/// hash when the same rel_path exists under multiple roots.
|
|
#[serde(default)]
|
|
pub library: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct RateInsightRequest {
|
|
pub file_path: String,
|
|
pub approved: bool,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct ExportTrainingDataQuery {
|
|
#[serde(default)]
|
|
pub approved_only: Option<bool>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct PhotoInsightResponse {
|
|
pub id: i32,
|
|
pub file_path: String,
|
|
pub title: String,
|
|
pub summary: String,
|
|
pub generated_at: i64,
|
|
pub model_version: String,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub prompt_eval_count: Option<i32>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub eval_count: Option<i32>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub approved: Option<bool>,
|
|
pub backend: String,
|
|
/// True when the insight was generated agentically and a chat
|
|
/// continuation can be started against it. Drives the mobile chat button.
|
|
pub has_training_messages: bool,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct AvailableModelsResponse {
|
|
pub primary: ServerModels,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub fallback: Option<ServerModels>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct ServerModels {
|
|
pub url: String,
|
|
pub models: Vec<ModelCapabilities>,
|
|
pub default_model: String,
|
|
}
|
|
|
|
/// POST /insights/generate - Generate insight for a specific photo
|
|
#[post("/insights/generate")]
|
|
pub async fn generate_insight_handler(
|
|
http_request: HttpRequest,
|
|
_claims: Claims,
|
|
request: web::Json<GeneratePhotoInsightRequest>,
|
|
insight_generator: web::Data<InsightGenerator>,
|
|
) -> impl Responder {
|
|
let parent_context = extract_context_from_request(&http_request);
|
|
let tracer = global_tracer();
|
|
let mut span = tracer.start_with_context("http.insights.generate", &parent_context);
|
|
|
|
let normalized_path = normalize_path(&request.file_path);
|
|
|
|
span.set_attribute(KeyValue::new("file_path", normalized_path.clone()));
|
|
if let Some(ref model) = request.model {
|
|
span.set_attribute(KeyValue::new("model", model.clone()));
|
|
}
|
|
if let Some(ref prompt) = request.system_prompt {
|
|
span.set_attribute(KeyValue::new("has_custom_prompt", true));
|
|
span.set_attribute(KeyValue::new("prompt_length", prompt.len() as i64));
|
|
}
|
|
if let Some(ctx) = request.num_ctx {
|
|
span.set_attribute(KeyValue::new("num_ctx", ctx as i64));
|
|
}
|
|
|
|
log::info!(
|
|
"Manual insight generation triggered for photo: {} with model: {:?}, custom_prompt: {}, num_ctx: {:?}",
|
|
normalized_path,
|
|
request.model,
|
|
request.system_prompt.is_some(),
|
|
request.num_ctx
|
|
);
|
|
|
|
// Generate insight with optional custom model, system prompt, and context size
|
|
let result = insight_generator
|
|
.generate_insight_for_photo_with_config(
|
|
&normalized_path,
|
|
request.model.clone(),
|
|
request.system_prompt.clone(),
|
|
request.num_ctx,
|
|
request.temperature,
|
|
request.top_p,
|
|
request.top_k,
|
|
request.min_p,
|
|
)
|
|
.await;
|
|
|
|
match result {
|
|
Ok(()) => {
|
|
span.set_status(Status::Ok);
|
|
HttpResponse::Ok().json(serde_json::json!({
|
|
"success": true,
|
|
"message": "Insight generated successfully"
|
|
}))
|
|
}
|
|
Err(e) => {
|
|
log::error!("Failed to generate insight: {:?}", e);
|
|
span.set_status(Status::error(e.to_string()));
|
|
HttpResponse::InternalServerError().json(serde_json::json!({
|
|
"error": format!("Failed to generate insight: {:?}", e)
|
|
}))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// GET /insights?path=/path/to/photo.jpg - Fetch insight for specific photo
|
|
#[get("/insights")]
|
|
pub async fn get_insight_handler(
|
|
_claims: Claims,
|
|
query: web::Query<GetPhotoInsightQuery>,
|
|
app_state: web::Data<AppState>,
|
|
insight_dao: web::Data<std::sync::Mutex<Box<dyn InsightDao>>>,
|
|
exif_dao: web::Data<std::sync::Mutex<Box<dyn ExifDao>>>,
|
|
) -> impl Responder {
|
|
let normalized_path = normalize_path(&query.path);
|
|
log::debug!("Fetching insight for {}", normalized_path);
|
|
|
|
let otel_context = opentelemetry::Context::new();
|
|
|
|
// Expand to rel_paths sharing content so an insight generated under
|
|
// library 1 still shows when the same photo is viewed from library 2.
|
|
let library = libraries::resolve_library_param(&app_state, query.library.as_deref())
|
|
.ok()
|
|
.flatten()
|
|
.unwrap_or_else(|| app_state.primary_library());
|
|
let sibling_paths = {
|
|
let mut exif = exif_dao.lock().expect("Unable to lock ExifDao");
|
|
exif.get_rel_paths_sharing_content(&otel_context, library.id, &normalized_path)
|
|
.unwrap_or_else(|_| vec![normalized_path.clone()])
|
|
};
|
|
|
|
let mut dao = insight_dao.lock().expect("Unable to lock InsightDao");
|
|
|
|
match dao.get_insight_for_paths(&otel_context, &sibling_paths) {
|
|
Ok(Some(insight)) => {
|
|
let response = PhotoInsightResponse {
|
|
id: insight.id,
|
|
file_path: insight.file_path,
|
|
title: insight.title,
|
|
summary: insight.summary,
|
|
generated_at: insight.generated_at,
|
|
model_version: insight.model_version,
|
|
prompt_eval_count: None,
|
|
eval_count: None,
|
|
approved: insight.approved,
|
|
has_training_messages: insight.training_messages.is_some(),
|
|
backend: insight.backend,
|
|
};
|
|
HttpResponse::Ok().json(response)
|
|
}
|
|
Ok(None) => HttpResponse::NotFound().json(serde_json::json!({
|
|
"error": "Insight not found"
|
|
})),
|
|
Err(e) => {
|
|
log::error!("Failed to fetch insight ({}): {:?}", &query.path, e);
|
|
HttpResponse::InternalServerError().json(serde_json::json!({
|
|
"error": format!("Failed to fetch insight: {:?}", e)
|
|
}))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// DELETE /insights?path=/path/to/photo.jpg - Remove insight (will regenerate on next request)
|
|
#[delete("/insights")]
|
|
pub async fn delete_insight_handler(
|
|
_claims: Claims,
|
|
query: web::Query<GetPhotoInsightQuery>,
|
|
insight_dao: web::Data<std::sync::Mutex<Box<dyn InsightDao>>>,
|
|
) -> impl Responder {
|
|
let normalized_path = normalize_path(&query.path);
|
|
log::info!("Deleting insight for {}", normalized_path);
|
|
|
|
let otel_context = opentelemetry::Context::new();
|
|
let mut dao = insight_dao.lock().expect("Unable to lock InsightDao");
|
|
|
|
match dao.delete_insight(&otel_context, &normalized_path) {
|
|
Ok(()) => HttpResponse::Ok().json(serde_json::json!({
|
|
"success": true,
|
|
"message": "Insight deleted successfully"
|
|
})),
|
|
Err(e) => {
|
|
log::error!("Failed to delete insight: {:?}", e);
|
|
HttpResponse::InternalServerError().json(serde_json::json!({
|
|
"error": format!("Failed to delete insight: {:?}", e)
|
|
}))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// GET /insights/all - Get all insights
|
|
#[get("/insights/all")]
|
|
pub async fn get_all_insights_handler(
|
|
_claims: Claims,
|
|
insight_dao: web::Data<std::sync::Mutex<Box<dyn InsightDao>>>,
|
|
) -> impl Responder {
|
|
log::debug!("Fetching all insights");
|
|
|
|
let otel_context = opentelemetry::Context::new();
|
|
let mut dao = insight_dao.lock().expect("Unable to lock InsightDao");
|
|
|
|
match dao.get_all_insights(&otel_context) {
|
|
Ok(insights) => {
|
|
let responses: Vec<PhotoInsightResponse> = insights
|
|
.into_iter()
|
|
.map(|insight| PhotoInsightResponse {
|
|
id: insight.id,
|
|
file_path: insight.file_path,
|
|
title: insight.title,
|
|
summary: insight.summary,
|
|
generated_at: insight.generated_at,
|
|
model_version: insight.model_version,
|
|
prompt_eval_count: None,
|
|
eval_count: None,
|
|
approved: insight.approved,
|
|
has_training_messages: insight.training_messages.is_some(),
|
|
backend: insight.backend,
|
|
})
|
|
.collect();
|
|
|
|
HttpResponse::Ok().json(responses)
|
|
}
|
|
Err(e) => {
|
|
log::error!("Failed to fetch all insights: {:?}", e);
|
|
HttpResponse::InternalServerError().json(serde_json::json!({
|
|
"error": format!("Failed to fetch insights: {:?}", e)
|
|
}))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// POST /insights/generate/agentic - Generate insight using agentic tool-calling loop
|
|
#[post("/insights/generate/agentic")]
|
|
pub async fn generate_agentic_insight_handler(
|
|
http_request: HttpRequest,
|
|
_claims: Claims,
|
|
request: web::Json<GeneratePhotoInsightRequest>,
|
|
insight_generator: web::Data<InsightGenerator>,
|
|
insight_dao: web::Data<std::sync::Mutex<Box<dyn InsightDao>>>,
|
|
) -> impl Responder {
|
|
let parent_context = extract_context_from_request(&http_request);
|
|
let tracer = global_tracer();
|
|
let mut span = tracer.start_with_context("http.insights.generate_agentic", &parent_context);
|
|
|
|
let normalized_path = normalize_path(&request.file_path);
|
|
|
|
span.set_attribute(KeyValue::new("file_path", normalized_path.clone()));
|
|
if let Some(ref model) = request.model {
|
|
span.set_attribute(KeyValue::new("model", model.clone()));
|
|
}
|
|
if let Some(ref prompt) = request.system_prompt {
|
|
span.set_attribute(KeyValue::new("has_custom_prompt", true));
|
|
span.set_attribute(KeyValue::new("prompt_length", prompt.len() as i64));
|
|
}
|
|
if let Some(ctx) = request.num_ctx {
|
|
span.set_attribute(KeyValue::new("num_ctx", ctx as i64));
|
|
}
|
|
|
|
let max_iterations: usize = std::env::var("AGENTIC_MAX_ITERATIONS")
|
|
.ok()
|
|
.and_then(|v| v.parse().ok())
|
|
.unwrap_or(12);
|
|
|
|
span.set_attribute(KeyValue::new("max_iterations", max_iterations as i64));
|
|
|
|
log::info!(
|
|
"Agentic insight generation triggered for photo: {} with model: {:?}, max_iterations: {}",
|
|
normalized_path,
|
|
request.model,
|
|
max_iterations
|
|
);
|
|
|
|
if let Some(ref b) = request.backend {
|
|
span.set_attribute(KeyValue::new("backend", b.clone()));
|
|
}
|
|
|
|
let result = insight_generator
|
|
.generate_agentic_insight_for_photo(
|
|
&normalized_path,
|
|
request.model.clone(),
|
|
request.system_prompt.clone(),
|
|
request.num_ctx,
|
|
request.temperature,
|
|
request.top_p,
|
|
request.top_k,
|
|
request.min_p,
|
|
max_iterations,
|
|
request.backend.clone(),
|
|
)
|
|
.await;
|
|
|
|
match result {
|
|
Ok((prompt_eval_count, eval_count)) => {
|
|
span.set_status(Status::Ok);
|
|
// Fetch the stored insight to return it
|
|
let otel_context = opentelemetry::Context::new();
|
|
let mut dao = insight_dao.lock().expect("Unable to lock InsightDao");
|
|
match dao.get_insight(&otel_context, &normalized_path) {
|
|
Ok(Some(insight)) => {
|
|
let response = PhotoInsightResponse {
|
|
id: insight.id,
|
|
file_path: insight.file_path,
|
|
title: insight.title,
|
|
summary: insight.summary,
|
|
generated_at: insight.generated_at,
|
|
model_version: insight.model_version,
|
|
prompt_eval_count,
|
|
eval_count,
|
|
approved: insight.approved,
|
|
has_training_messages: insight.training_messages.is_some(),
|
|
backend: insight.backend,
|
|
};
|
|
HttpResponse::Ok().json(response)
|
|
}
|
|
Ok(None) => HttpResponse::Ok().json(serde_json::json!({
|
|
"success": true,
|
|
"message": "Agentic insight generated successfully"
|
|
})),
|
|
Err(e) => {
|
|
log::warn!("Insight stored but failed to retrieve: {:?}", e);
|
|
HttpResponse::Ok().json(serde_json::json!({
|
|
"success": true,
|
|
"message": "Agentic insight generated successfully"
|
|
}))
|
|
}
|
|
}
|
|
}
|
|
Err(e) => {
|
|
let error_msg = format!("{:?}", e);
|
|
log::error!("Failed to generate agentic insight: {}", error_msg);
|
|
span.set_status(Status::error(error_msg.clone()));
|
|
|
|
if error_msg.contains("tool calling not supported")
|
|
|| error_msg.contains("model not available")
|
|
{
|
|
HttpResponse::BadRequest().json(serde_json::json!({
|
|
"error": format!("Failed to generate agentic insight: {}", error_msg)
|
|
}))
|
|
} else if error_msg.contains("error parsing tool call") {
|
|
HttpResponse::BadRequest().json(serde_json::json!({
|
|
"error": "Model is not compatible with Ollama's tool calling protocol. Try a model known to support native tool calling (e.g. llama3.1, llama3.2, qwen2.5, mistral-nemo)."
|
|
}))
|
|
} else {
|
|
HttpResponse::InternalServerError().json(serde_json::json!({
|
|
"error": format!("Failed to generate agentic insight: {}", error_msg)
|
|
}))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// GET /insights/models - List available models from both servers with capabilities
|
|
#[get("/insights/models")]
|
|
pub async fn get_available_models_handler(
|
|
_claims: Claims,
|
|
app_state: web::Data<crate::state::AppState>,
|
|
) -> impl Responder {
|
|
log::debug!("Fetching available models with capabilities");
|
|
|
|
let ollama_client = &app_state.ollama;
|
|
|
|
// Fetch models with capabilities from primary server
|
|
let primary_models =
|
|
match OllamaClient::list_models_with_capabilities(&ollama_client.primary_url).await {
|
|
Ok(models) => models,
|
|
Err(e) => {
|
|
log::warn!("Failed to fetch models from primary server: {:?}", e);
|
|
vec![]
|
|
}
|
|
};
|
|
|
|
let primary = ServerModels {
|
|
url: ollama_client.primary_url.clone(),
|
|
models: primary_models,
|
|
default_model: ollama_client.primary_model.clone(),
|
|
};
|
|
|
|
// Fetch models with capabilities from fallback server if configured
|
|
let fallback = if let Some(fallback_url) = &ollama_client.fallback_url {
|
|
match OllamaClient::list_models_with_capabilities(fallback_url).await {
|
|
Ok(models) => Some(ServerModels {
|
|
url: fallback_url.clone(),
|
|
models,
|
|
default_model: ollama_client
|
|
.fallback_model
|
|
.clone()
|
|
.unwrap_or_else(|| ollama_client.primary_model.clone()),
|
|
}),
|
|
Err(e) => {
|
|
log::warn!("Failed to fetch models from fallback server: {:?}", e);
|
|
None
|
|
}
|
|
}
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let response = AvailableModelsResponse { primary, fallback };
|
|
|
|
HttpResponse::Ok().json(response)
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct OpenRouterModelsResponse {
|
|
pub models: Vec<String>,
|
|
pub default_model: Option<String>,
|
|
pub configured: bool,
|
|
}
|
|
|
|
/// GET /insights/openrouter/models - Curated OpenRouter model ids exposed
|
|
/// to clients for the hybrid backend. Returned verbatim from
|
|
/// `OPENROUTER_ALLOWED_MODELS`; no live call to OpenRouter.
|
|
#[get("/insights/openrouter/models")]
|
|
pub async fn get_openrouter_models_handler(
|
|
_claims: Claims,
|
|
app_state: web::Data<crate::state::AppState>,
|
|
) -> impl Responder {
|
|
let configured = app_state.openrouter.is_some();
|
|
let default_model = app_state
|
|
.openrouter
|
|
.as_ref()
|
|
.map(|c| c.primary_model.clone());
|
|
let response = OpenRouterModelsResponse {
|
|
models: app_state.openrouter_allowed_models.clone(),
|
|
default_model,
|
|
configured,
|
|
};
|
|
HttpResponse::Ok().json(response)
|
|
}
|
|
|
|
/// POST /insights/rate - Rate an insight (thumbs up/down for training data)
|
|
#[post("/insights/rate")]
|
|
pub async fn rate_insight_handler(
|
|
_claims: Claims,
|
|
request: web::Json<RateInsightRequest>,
|
|
insight_dao: web::Data<std::sync::Mutex<Box<dyn InsightDao>>>,
|
|
) -> impl Responder {
|
|
let normalized_path = normalize_path(&request.file_path);
|
|
log::info!(
|
|
"Rating insight for {}: approved={}",
|
|
normalized_path,
|
|
request.approved
|
|
);
|
|
|
|
let otel_context = opentelemetry::Context::new();
|
|
let mut dao = insight_dao.lock().expect("Unable to lock InsightDao");
|
|
|
|
match dao.rate_insight(&otel_context, &normalized_path, request.approved) {
|
|
Ok(()) => HttpResponse::Ok().json(serde_json::json!({
|
|
"success": true,
|
|
"message": "Insight rated successfully"
|
|
})),
|
|
Err(e) => {
|
|
log::error!("Failed to rate insight: {:?}", e);
|
|
HttpResponse::InternalServerError().json(serde_json::json!({
|
|
"error": format!("Failed to rate insight: {:?}", e)
|
|
}))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// GET /insights/training-data - Export approved training data as JSONL
|
|
#[get("/insights/training-data")]
|
|
pub async fn export_training_data_handler(
|
|
_claims: Claims,
|
|
query: web::Query<ExportTrainingDataQuery>,
|
|
insight_dao: web::Data<std::sync::Mutex<Box<dyn InsightDao>>>,
|
|
) -> impl Responder {
|
|
let approved_only = query.approved_only.unwrap_or(true);
|
|
log::info!("Exporting training data (approved_only={})", approved_only);
|
|
|
|
let otel_context = opentelemetry::Context::new();
|
|
let mut dao = insight_dao.lock().expect("Unable to lock InsightDao");
|
|
|
|
let insights = if approved_only {
|
|
dao.get_approved_insights(&otel_context)
|
|
} else {
|
|
dao.get_all_insights(&otel_context)
|
|
};
|
|
|
|
match insights {
|
|
Ok(insights) => {
|
|
let mut jsonl = String::new();
|
|
for insight in &insights {
|
|
if let Some(ref messages) = insight.training_messages {
|
|
let entry = serde_json::json!({
|
|
"file_path": insight.file_path,
|
|
"model_version": insight.model_version,
|
|
"generated_at": insight.generated_at,
|
|
"title": insight.title,
|
|
"summary": insight.summary,
|
|
"messages": serde_json::from_str::<serde_json::Value>(messages)
|
|
.unwrap_or(serde_json::Value::Null),
|
|
});
|
|
jsonl.push_str(&entry.to_string());
|
|
jsonl.push('\n');
|
|
}
|
|
}
|
|
|
|
HttpResponse::Ok()
|
|
.content_type("application/jsonl")
|
|
.insert_header((
|
|
"Content-Disposition",
|
|
"attachment; filename=\"training_data.jsonl\"",
|
|
))
|
|
.body(jsonl)
|
|
}
|
|
Err(e) => {
|
|
log::error!("Failed to export training data: {:?}", e);
|
|
HttpResponse::InternalServerError().json(serde_json::json!({
|
|
"error": format!("Failed to export training data: {:?}", e)
|
|
}))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct ChatTurnHttpRequest {
|
|
pub file_path: String,
|
|
#[serde(default)]
|
|
pub library: Option<String>,
|
|
pub user_message: String,
|
|
#[serde(default)]
|
|
pub model: Option<String>,
|
|
#[serde(default)]
|
|
pub backend: Option<String>,
|
|
#[serde(default)]
|
|
pub num_ctx: Option<i32>,
|
|
#[serde(default)]
|
|
pub temperature: Option<f32>,
|
|
#[serde(default)]
|
|
pub top_p: Option<f32>,
|
|
#[serde(default)]
|
|
pub top_k: Option<i32>,
|
|
#[serde(default)]
|
|
pub min_p: Option<f32>,
|
|
#[serde(default)]
|
|
pub max_iterations: Option<usize>,
|
|
#[serde(default)]
|
|
pub amend: bool,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct ChatTurnHttpResponse {
|
|
pub assistant_message: String,
|
|
pub tool_calls_made: usize,
|
|
pub iterations_used: usize,
|
|
pub truncated: bool,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub prompt_eval_count: Option<i32>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub eval_count: Option<i32>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub amended_insight_id: Option<i32>,
|
|
pub backend: String,
|
|
pub model: String,
|
|
}
|
|
|
|
/// POST /insights/chat — submit a follow-up turn against an existing insight.
|
|
#[post("/insights/chat")]
|
|
pub async fn chat_turn_handler(
|
|
http_request: HttpRequest,
|
|
_claims: Claims,
|
|
request: web::Json<ChatTurnHttpRequest>,
|
|
app_state: web::Data<AppState>,
|
|
) -> impl Responder {
|
|
let parent_context = extract_context_from_request(&http_request);
|
|
let tracer = global_tracer();
|
|
let mut span = tracer.start_with_context("http.insights.chat", &parent_context);
|
|
span.set_attribute(KeyValue::new("file_path", request.file_path.clone()));
|
|
|
|
let library = match libraries::resolve_library_param(&app_state, request.library.as_deref()) {
|
|
Ok(Some(lib)) => lib,
|
|
Ok(None) => app_state.primary_library(),
|
|
Err(e) => {
|
|
return HttpResponse::BadRequest().json(serde_json::json!({
|
|
"error": format!("invalid library: {}", e)
|
|
}));
|
|
}
|
|
};
|
|
|
|
let chat_req = ChatTurnRequest {
|
|
library_id: library.id,
|
|
file_path: request.file_path.clone(),
|
|
user_message: request.user_message.clone(),
|
|
model: request.model.clone(),
|
|
backend: request.backend.clone(),
|
|
num_ctx: request.num_ctx,
|
|
temperature: request.temperature,
|
|
top_p: request.top_p,
|
|
top_k: request.top_k,
|
|
min_p: request.min_p,
|
|
max_iterations: request.max_iterations,
|
|
amend: request.amend,
|
|
};
|
|
|
|
match app_state.insight_chat.chat_turn(chat_req).await {
|
|
Ok(result) => {
|
|
span.set_status(Status::Ok);
|
|
HttpResponse::Ok().json(ChatTurnHttpResponse {
|
|
assistant_message: result.assistant_message,
|
|
tool_calls_made: result.tool_calls_made,
|
|
iterations_used: result.iterations_used,
|
|
truncated: result.truncated,
|
|
prompt_eval_count: result.prompt_eval_count,
|
|
eval_count: result.eval_count,
|
|
amended_insight_id: result.amended_insight_id,
|
|
backend: result.backend_used,
|
|
model: result.model_used,
|
|
})
|
|
}
|
|
Err(e) => {
|
|
let msg = format!("{}", e);
|
|
log::error!("Chat turn failed: {}", msg);
|
|
span.set_status(Status::error(msg.clone()));
|
|
|
|
// Map well-known errors to client-facing 4xx codes.
|
|
if msg.contains("no insight found") {
|
|
HttpResponse::NotFound().json(serde_json::json!({ "error": msg }))
|
|
} else if msg.contains("no chat history") {
|
|
HttpResponse::Conflict().json(serde_json::json!({ "error": msg }))
|
|
} else if msg.contains("user_message")
|
|
|| msg.contains("unknown backend")
|
|
|| msg.contains("switching from local to hybrid")
|
|
|| msg.contains("hybrid backend unavailable")
|
|
{
|
|
HttpResponse::BadRequest().json(serde_json::json!({ "error": msg }))
|
|
} else {
|
|
HttpResponse::InternalServerError().json(serde_json::json!({ "error": msg }))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct ChatHistoryQuery {
|
|
pub path: String,
|
|
#[serde(default)]
|
|
pub library: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct ChatHistoryHttpResponse {
|
|
pub messages: Vec<RenderedHistoryMessage>,
|
|
pub turn_count: usize,
|
|
pub model_version: String,
|
|
pub backend: String,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct RenderedHistoryMessage {
|
|
pub role: String,
|
|
pub content: String,
|
|
pub is_initial: bool,
|
|
#[serde(skip_serializing_if = "Vec::is_empty")]
|
|
pub tools: Vec<HistoryToolInvocation>,
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub struct HistoryToolInvocation {
|
|
pub name: String,
|
|
pub arguments: serde_json::Value,
|
|
pub result: String,
|
|
#[serde(skip_serializing_if = "std::ops::Not::not")]
|
|
pub result_truncated: bool,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct ChatRewindHttpRequest {
|
|
pub file_path: String,
|
|
#[serde(default)]
|
|
pub library: Option<String>,
|
|
/// 0-based index into the rendered transcript. The message at this
|
|
/// index, and everything after it, is discarded. Must be > 0 — the
|
|
/// initial user message is protected.
|
|
pub discard_from_rendered_index: usize,
|
|
}
|
|
|
|
/// POST /insights/chat/rewind — truncate the stored conversation so the
|
|
/// rendered message at `discard_from_rendered_index` (and everything after)
|
|
/// is removed. Use when a user wants to retry a turn with a different
|
|
/// prompt without prior replies poisoning context.
|
|
#[post("/insights/chat/rewind")]
|
|
pub async fn chat_rewind_handler(
|
|
_claims: Claims,
|
|
request: web::Json<ChatRewindHttpRequest>,
|
|
app_state: web::Data<AppState>,
|
|
) -> impl Responder {
|
|
let library = match libraries::resolve_library_param(&app_state, request.library.as_deref()) {
|
|
Ok(Some(lib)) => lib,
|
|
Ok(None) => app_state.primary_library(),
|
|
Err(e) => {
|
|
return HttpResponse::BadRequest().json(serde_json::json!({
|
|
"error": format!("invalid library: {}", e)
|
|
}));
|
|
}
|
|
};
|
|
|
|
match app_state
|
|
.insight_chat
|
|
.rewind_history(
|
|
library.id,
|
|
&request.file_path,
|
|
request.discard_from_rendered_index,
|
|
)
|
|
.await
|
|
{
|
|
Ok(()) => HttpResponse::Ok().json(serde_json::json!({ "success": true })),
|
|
Err(e) => {
|
|
let msg = format!("{}", e);
|
|
log::error!("Chat rewind failed: {}", msg);
|
|
if msg.contains("no insight found") {
|
|
HttpResponse::NotFound().json(serde_json::json!({ "error": msg }))
|
|
} else if msg.contains("no chat history") {
|
|
HttpResponse::Conflict().json(serde_json::json!({ "error": msg }))
|
|
} else if msg.contains("cannot discard the initial") || msg.contains("out of range") {
|
|
HttpResponse::BadRequest().json(serde_json::json!({ "error": msg }))
|
|
} else {
|
|
HttpResponse::InternalServerError().json(serde_json::json!({ "error": msg }))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// GET /insights/chat/history — return the rendered transcript for a photo.
|
|
#[get("/insights/chat/history")]
|
|
pub async fn chat_history_handler(
|
|
_claims: Claims,
|
|
query: web::Query<ChatHistoryQuery>,
|
|
app_state: web::Data<AppState>,
|
|
) -> impl Responder {
|
|
// library param parsed for parity with other insight endpoints, even
|
|
// though load_history currently keys on file_path alone (matches the
|
|
// existing get_insight DAO contract).
|
|
let _library = libraries::resolve_library_param(&app_state, query.library.as_deref())
|
|
.ok()
|
|
.flatten()
|
|
.unwrap_or_else(|| app_state.primary_library());
|
|
|
|
match app_state.insight_chat.load_history(&query.path) {
|
|
Ok(view) => HttpResponse::Ok().json(ChatHistoryHttpResponse {
|
|
messages: view
|
|
.messages
|
|
.into_iter()
|
|
.map(|m| RenderedHistoryMessage {
|
|
role: m.role,
|
|
content: m.content,
|
|
is_initial: m.is_initial,
|
|
tools: m
|
|
.tools
|
|
.into_iter()
|
|
.map(|t| HistoryToolInvocation {
|
|
name: t.name,
|
|
arguments: t.arguments,
|
|
result: t.result,
|
|
result_truncated: t.result_truncated,
|
|
})
|
|
.collect(),
|
|
})
|
|
.collect(),
|
|
turn_count: view.turn_count,
|
|
model_version: view.model_version,
|
|
backend: view.backend,
|
|
}),
|
|
Err(e) => {
|
|
let msg = format!("{}", e);
|
|
if msg.contains("no insight found") {
|
|
HttpResponse::NotFound().json(serde_json::json!({ "error": msg }))
|
|
} else if msg.contains("no chat history") {
|
|
HttpResponse::Conflict().json(serde_json::json!({ "error": msg }))
|
|
} else {
|
|
HttpResponse::InternalServerError().json(serde_json::json!({ "error": msg }))
|
|
}
|
|
}
|
|
}
|
|
}
|