Implement persistent conversational AI chat
This commit is contained in:
861
crates/bds-core/src/engine/chat_tools.rs
Normal file
861
crates/bds-core/src/engine/chat_tools.rs
Normal file
@@ -0,0 +1,861 @@
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
|
||||
use base64::Engine as _;
|
||||
use diesel::prelude::*;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use crate::db::DbConnection as Connection;
|
||||
use crate::db::queries::{media, post, post_link, post_media, script, template};
|
||||
use crate::db::schema::ai_models;
|
||||
use crate::engine::{EngineError, EngineResult};
|
||||
use crate::util::frontmatter::read_post_file;
|
||||
|
||||
pub fn model_supports_tools(conn: &Connection, model: &str) -> EngineResult<bool> {
|
||||
let catalog_value = conn.with(|connection| {
|
||||
ai_models::table
|
||||
.filter(ai_models::model_id.eq(model))
|
||||
.select(ai_models::tool_call)
|
||||
.first::<i32>(connection)
|
||||
.optional()
|
||||
})?;
|
||||
Ok(catalog_value.map_or_else(
|
||||
|| {
|
||||
let model = model.to_ascii_lowercase();
|
||||
model.contains("gpt")
|
||||
|| model.contains("claude")
|
||||
|| model.contains("tool")
|
||||
|| model.contains("qwen")
|
||||
|| model.contains("mistral")
|
||||
},
|
||||
|value| value != 0,
|
||||
))
|
||||
}
|
||||
|
||||
pub fn system_prompt(conn: &Connection, project_id: &str) -> EngineResult<String> {
|
||||
let posts = post::list_posts_by_project(conn, project_id)?;
|
||||
let media_count = media::count_media_by_project(conn, project_id)?;
|
||||
let tags = posts
|
||||
.iter()
|
||||
.flat_map(|post| post.tags.iter())
|
||||
.collect::<BTreeSet<_>>()
|
||||
.len();
|
||||
let categories = posts
|
||||
.iter()
|
||||
.flat_map(|post| post.categories.iter())
|
||||
.collect::<BTreeSet<_>>()
|
||||
.len();
|
||||
let configured = crate::engine::settings::get(conn, "ai.system_prompt")?.unwrap_or_default();
|
||||
let contract = format!(
|
||||
"You are the conversational assistant for this blog project. Use tools when facts from the project are needed. Never invent project content or identifiers. There are {} posts, {media_count} media items, {tags} tags, and {categories} categories. Keep answers concise and use GitHub-flavored Markdown when useful.",
|
||||
posts.len()
|
||||
);
|
||||
Ok(if configured.trim().is_empty() {
|
||||
contract
|
||||
} else {
|
||||
format!("{}\n\n{contract}", configured.trim())
|
||||
})
|
||||
}
|
||||
|
||||
pub fn tool_specs() -> Vec<Value> {
|
||||
vec![
|
||||
spec(
|
||||
"get_blog_stats",
|
||||
"Return aggregate project statistics.",
|
||||
json!({}),
|
||||
),
|
||||
spec(
|
||||
"check_term",
|
||||
"Check whether a term is used as a tag or category.",
|
||||
json!({"term": {"type": "string"}}),
|
||||
),
|
||||
spec(
|
||||
"search_posts",
|
||||
"Search post titles, slugs, excerpts, bodies, tags, and categories.",
|
||||
json!({"query": {"type": "string"}, "language": {"type": "string"}, "limit": {"type": "integer"}}),
|
||||
),
|
||||
spec(
|
||||
"read_post",
|
||||
"Read one post by id.",
|
||||
json!({"post_id": {"type": "string"}}),
|
||||
),
|
||||
spec(
|
||||
"read_post_by_slug",
|
||||
"Read one post by slug.",
|
||||
json!({"slug": {"type": "string"}}),
|
||||
),
|
||||
spec(
|
||||
"list_posts",
|
||||
"List posts, optionally filtering by status, tag, or category.",
|
||||
json!({"status": {"type": "string"}, "tag": {"type": "string"}, "category": {"type": "string"}, "limit": {"type": "integer"}}),
|
||||
),
|
||||
spec(
|
||||
"count_posts",
|
||||
"Count posts and optionally group by status, tag, or category.",
|
||||
json!({"group_by": {"type": "string", "enum": ["status", "tag", "category"]}}),
|
||||
),
|
||||
spec(
|
||||
"update_post_metadata",
|
||||
"Update title, excerpt, tags, or categories on a post.",
|
||||
json!({"post_id": {"type": "string"}, "title": {"type": "string"}, "excerpt": {"type": ["string", "null"]}, "tags": {"type": "array", "items": {"type": "string"}}, "categories": {"type": "array", "items": {"type": "string"}}}),
|
||||
),
|
||||
spec(
|
||||
"list_media",
|
||||
"List project media.",
|
||||
json!({"limit": {"type": "integer"}}),
|
||||
),
|
||||
spec(
|
||||
"get_media",
|
||||
"Get one media item.",
|
||||
json!({"media_id": {"type": "string"}}),
|
||||
),
|
||||
spec(
|
||||
"view_image",
|
||||
"Return a local image thumbnail as a data URL for visual inspection.",
|
||||
json!({"media_id": {"type": "string"}, "size": {"type": "string", "enum": ["small", "medium", "large"]}}),
|
||||
),
|
||||
spec(
|
||||
"update_media_metadata",
|
||||
"Update title, alt text, caption, or tags on media.",
|
||||
json!({"media_id": {"type": "string"}, "title": {"type": ["string", "null"]}, "alt": {"type": ["string", "null"]}, "caption": {"type": ["string", "null"]}, "tags": {"type": "array", "items": {"type": "string"}}}),
|
||||
),
|
||||
spec("list_tags", "List tags and usage counts.", json!({})),
|
||||
spec(
|
||||
"list_categories",
|
||||
"List categories and usage counts.",
|
||||
json!({}),
|
||||
),
|
||||
spec(
|
||||
"get_post_backlinks",
|
||||
"Get posts that link to a post.",
|
||||
json!({"post_id": {"type": "string"}}),
|
||||
),
|
||||
spec(
|
||||
"get_post_outlinks",
|
||||
"Get posts linked from a post.",
|
||||
json!({"post_id": {"type": "string"}}),
|
||||
),
|
||||
spec(
|
||||
"get_post_media",
|
||||
"Get media linked to a post.",
|
||||
json!({"post_id": {"type": "string"}}),
|
||||
),
|
||||
spec(
|
||||
"get_media_posts",
|
||||
"Get posts that use a media item.",
|
||||
json!({"media_id": {"type": "string"}}),
|
||||
),
|
||||
spec("list_templates", "List templates.", json!({})),
|
||||
spec(
|
||||
"read_template",
|
||||
"Read a template by id.",
|
||||
json!({"template_id": {"type": "string"}}),
|
||||
),
|
||||
spec("list_scripts", "List scripts.", json!({})),
|
||||
spec(
|
||||
"read_script",
|
||||
"Read a script by id.",
|
||||
json!({"script_id": {"type": "string"}}),
|
||||
),
|
||||
spec(
|
||||
"navigate",
|
||||
"Open a project area or entity in the application.",
|
||||
json!({
|
||||
"action": {"type": "string", "enum": ["open_post", "open_media", "open_settings", "open_chat", "switch_view", "toggle_sidebar", "toggle_panel", "toggle_assistant_sidebar"]},
|
||||
"destination": {"type": "string", "enum": ["posts", "pages", "media", "templates", "scripts", "tags", "chat", "import", "git", "settings"]},
|
||||
"entity_id": {"type": "string"},
|
||||
"value": {"type": "string"}
|
||||
}),
|
||||
),
|
||||
]
|
||||
}
|
||||
|
||||
pub fn execute(
|
||||
conn: &Connection,
|
||||
data_dir: &Path,
|
||||
project_id: &str,
|
||||
name: &str,
|
||||
arguments: &Value,
|
||||
) -> EngineResult<Value> {
|
||||
match name {
|
||||
"blog_stats" | "get_blog_stats" => blog_stats(conn, project_id),
|
||||
"check_term" => check_term(conn, project_id, required_str(arguments, "term")?),
|
||||
"search_posts" => search_posts(conn, project_id, arguments),
|
||||
"read_post" => {
|
||||
let item = post::get_post_by_id(conn, required_id(arguments, "post_id", "postId")?)?;
|
||||
ensure_project(&item.project_id, project_id)?;
|
||||
post_detail(data_dir, item)
|
||||
}
|
||||
"read_post_by_slug" => {
|
||||
let item = post::get_post_by_project_and_slug(
|
||||
conn,
|
||||
project_id,
|
||||
required_str(arguments, "slug")?,
|
||||
)?;
|
||||
post_detail(data_dir, item)
|
||||
}
|
||||
"list_posts" => list_posts(conn, project_id, arguments),
|
||||
"count_posts" => count_posts(conn, project_id, arguments),
|
||||
"update_post_metadata" => update_post_metadata(conn, data_dir, project_id, arguments),
|
||||
"list_media" => list_media(conn, project_id, arguments),
|
||||
"get_media" => {
|
||||
let item =
|
||||
media::get_media_by_id(conn, required_id(arguments, "media_id", "mediaId")?)?;
|
||||
ensure_project(&item.project_id, project_id)?;
|
||||
Ok(json!({"success": true, "media": item}))
|
||||
}
|
||||
"view_image" => view_image(conn, data_dir, project_id, arguments),
|
||||
"update_media_metadata" => update_media_metadata(conn, data_dir, project_id, arguments),
|
||||
"list_tags" => counted_terms(conn, project_id, true),
|
||||
"list_categories" => counted_terms(conn, project_id, false),
|
||||
"get_post_backlinks" => post_links(conn, project_id, arguments, true),
|
||||
"get_post_outlinks" => post_links(conn, project_id, arguments, false),
|
||||
"get_post_media" => linked_media(conn, project_id, arguments),
|
||||
"get_media_posts" => linked_posts(conn, project_id, arguments),
|
||||
"list_templates" => Ok(json!({
|
||||
"templates": template::list_templates_by_project(conn, project_id)?,
|
||||
})),
|
||||
"read_template" => {
|
||||
let item = template::get_template_by_id(
|
||||
conn,
|
||||
required_id(arguments, "template_id", "templateId")?,
|
||||
)?;
|
||||
ensure_project(&item.project_id, project_id)?;
|
||||
Ok(json!({"success": true, "template": item}))
|
||||
}
|
||||
"list_scripts" => Ok(json!({
|
||||
"scripts": script::list_scripts_by_project(conn, project_id)?,
|
||||
})),
|
||||
"read_script" => {
|
||||
let item =
|
||||
script::get_script_by_id(conn, required_id(arguments, "script_id", "scriptId")?)?;
|
||||
ensure_project(&item.project_id, project_id)?;
|
||||
Ok(json!({"success": true, "script": item}))
|
||||
}
|
||||
"navigate" => navigate(arguments),
|
||||
_ => Ok(json!({"success": false, "error": "unknown_tool", "name": name})),
|
||||
}
|
||||
}
|
||||
|
||||
fn blog_stats(conn: &Connection, project_id: &str) -> EngineResult<Value> {
|
||||
let posts = post::list_posts_by_project(conn, project_id)?;
|
||||
let media_count = media::count_media_by_project(conn, project_id)?;
|
||||
let templates = template::list_templates_by_project(conn, project_id)?.len();
|
||||
let scripts = script::list_scripts_by_project(conn, project_id)?.len();
|
||||
let tags = posts
|
||||
.iter()
|
||||
.flat_map(|item| &item.tags)
|
||||
.collect::<BTreeSet<_>>()
|
||||
.len();
|
||||
let categories = posts
|
||||
.iter()
|
||||
.flat_map(|item| &item.categories)
|
||||
.collect::<BTreeSet<_>>()
|
||||
.len();
|
||||
Ok(json!({
|
||||
"posts": posts.len(), "media": media_count, "templates": templates,
|
||||
"scripts": scripts, "tags": tags, "categories": categories,
|
||||
}))
|
||||
}
|
||||
|
||||
fn check_term(conn: &Connection, project_id: &str, term: &str) -> EngineResult<Value> {
|
||||
let term = term.to_lowercase();
|
||||
let posts = post::list_posts_by_project(conn, project_id)?;
|
||||
let tag_count = posts
|
||||
.iter()
|
||||
.filter(|item| item.tags.iter().any(|value| value.to_lowercase() == term))
|
||||
.count();
|
||||
let category_count = posts
|
||||
.iter()
|
||||
.filter(|item| {
|
||||
item.categories
|
||||
.iter()
|
||||
.any(|value| value.to_lowercase() == term)
|
||||
})
|
||||
.count();
|
||||
Ok(json!({"term": term, "tag_posts": tag_count, "category_posts": category_count}))
|
||||
}
|
||||
|
||||
fn search_posts(conn: &Connection, project_id: &str, arguments: &Value) -> EngineResult<Value> {
|
||||
let query = required_str(arguments, "query")?;
|
||||
let language = arguments
|
||||
.get("language")
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or("en");
|
||||
let limit = limit(arguments);
|
||||
let mut matches = Vec::new();
|
||||
for id in crate::db::fts::search_posts(conn, query, language)? {
|
||||
if let Ok(item) = post::get_post_by_id(conn, &id)
|
||||
&& item.project_id == project_id
|
||||
{
|
||||
matches.push(post_summary(&item));
|
||||
if matches.len() == limit {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(json!({"posts": matches, "count": matches.len()}))
|
||||
}
|
||||
|
||||
fn list_posts(conn: &Connection, project_id: &str, arguments: &Value) -> EngineResult<Value> {
|
||||
let status = arguments.get("status").and_then(Value::as_str);
|
||||
let tag = arguments.get("tag").and_then(Value::as_str);
|
||||
let category = arguments.get("category").and_then(Value::as_str);
|
||||
let items = post::list_posts_by_project(conn, project_id)?
|
||||
.into_iter()
|
||||
.filter(|item| status.is_none_or(|value| item.status.as_str() == value))
|
||||
.filter(|item| tag.is_none_or(|value| contains_case_insensitive(&item.tags, value)))
|
||||
.filter(|item| {
|
||||
category.is_none_or(|value| contains_case_insensitive(&item.categories, value))
|
||||
})
|
||||
.take(limit(arguments))
|
||||
.map(|item| post_summary(&item))
|
||||
.collect::<Vec<_>>();
|
||||
Ok(json!({"posts": items, "count": items.len()}))
|
||||
}
|
||||
|
||||
fn count_posts(conn: &Connection, project_id: &str, arguments: &Value) -> EngineResult<Value> {
|
||||
let items = post::list_posts_by_project(conn, project_id)?;
|
||||
let Some(group_by) = arguments
|
||||
.get("group_by")
|
||||
.or_else(|| arguments.get("groupBy"))
|
||||
.and_then(Value::as_str)
|
||||
else {
|
||||
return Ok(json!({"total_posts": items.len()}));
|
||||
};
|
||||
let mut groups = BTreeMap::<String, usize>::new();
|
||||
for item in &items {
|
||||
let values: Vec<String> = match group_by {
|
||||
"status" => vec![item.status.as_str().to_string()],
|
||||
"tag" => item.tags.clone(),
|
||||
"category" => item.categories.clone(),
|
||||
_ => {
|
||||
return Err(EngineError::Validation(format!(
|
||||
"unsupported post grouping: {group_by}"
|
||||
)));
|
||||
}
|
||||
};
|
||||
for value in values {
|
||||
*groups.entry(value).or_default() += 1;
|
||||
}
|
||||
}
|
||||
Ok(json!({"total_posts": items.len(), "group_by": group_by, "groups": groups}))
|
||||
}
|
||||
|
||||
fn update_post_metadata(
|
||||
conn: &Connection,
|
||||
data_dir: &Path,
|
||||
project_id: &str,
|
||||
arguments: &Value,
|
||||
) -> EngineResult<Value> {
|
||||
let id = required_id(arguments, "post_id", "postId")?;
|
||||
let existing = post::get_post_by_id(conn, id)?;
|
||||
ensure_project(&existing.project_id, project_id)?;
|
||||
if !["title", "excerpt", "tags", "categories"]
|
||||
.iter()
|
||||
.any(|key| arguments.get(key).is_some())
|
||||
{
|
||||
return Err(EngineError::Validation(
|
||||
"no post metadata updates provided".to_string(),
|
||||
));
|
||||
}
|
||||
let excerpt = optional_nullable_str(arguments, "excerpt")?;
|
||||
let item = crate::engine::post::update_post(
|
||||
conn,
|
||||
data_dir,
|
||||
id,
|
||||
arguments.get("title").and_then(Value::as_str),
|
||||
None,
|
||||
excerpt,
|
||||
None,
|
||||
optional_string_array(arguments, "tags")?,
|
||||
optional_string_array(arguments, "categories")?,
|
||||
None,
|
||||
None,
|
||||
None,
|
||||
None,
|
||||
)?;
|
||||
Ok(json!({"success": true, "post": post_summary(&item)}))
|
||||
}
|
||||
|
||||
fn list_media(conn: &Connection, project_id: &str, arguments: &Value) -> EngineResult<Value> {
|
||||
let items = media::list_media_by_project(conn, project_id)?
|
||||
.into_iter()
|
||||
.take(limit(arguments))
|
||||
.collect::<Vec<_>>();
|
||||
Ok(json!({"media": items, "count": items.len()}))
|
||||
}
|
||||
|
||||
fn update_media_metadata(
|
||||
conn: &Connection,
|
||||
data_dir: &Path,
|
||||
project_id: &str,
|
||||
arguments: &Value,
|
||||
) -> EngineResult<Value> {
|
||||
let id = required_id(arguments, "media_id", "mediaId")?;
|
||||
let existing = media::get_media_by_id(conn, id)?;
|
||||
ensure_project(&existing.project_id, project_id)?;
|
||||
if !["title", "alt", "caption", "tags"]
|
||||
.iter()
|
||||
.any(|key| arguments.get(key).is_some())
|
||||
{
|
||||
return Err(EngineError::Validation(
|
||||
"no media metadata updates provided".to_string(),
|
||||
));
|
||||
}
|
||||
let item = crate::engine::media::update_media(
|
||||
conn,
|
||||
data_dir,
|
||||
id,
|
||||
optional_nullable_str(arguments, "title")?,
|
||||
optional_nullable_str(arguments, "alt")?,
|
||||
optional_nullable_str(arguments, "caption")?,
|
||||
None,
|
||||
None,
|
||||
optional_string_array(arguments, "tags")?,
|
||||
)?;
|
||||
Ok(json!({"success": true, "media": item}))
|
||||
}
|
||||
|
||||
fn view_image(
|
||||
conn: &Connection,
|
||||
data_dir: &Path,
|
||||
project_id: &str,
|
||||
arguments: &Value,
|
||||
) -> EngineResult<Value> {
|
||||
let item = media::get_media_by_id(conn, required_id(arguments, "media_id", "mediaId")?)?;
|
||||
ensure_project(&item.project_id, project_id)?;
|
||||
if !item.mime_type.starts_with("image/") {
|
||||
return Ok(json!({"success": false, "error": "not_image", "mime_type": item.mime_type}));
|
||||
}
|
||||
let size = arguments
|
||||
.get("size")
|
||||
.and_then(Value::as_str)
|
||||
.unwrap_or("medium");
|
||||
if !["small", "medium", "large"].contains(&size) {
|
||||
return Err(EngineError::Validation(format!(
|
||||
"unsupported thumbnail size: {size}"
|
||||
)));
|
||||
}
|
||||
let path = data_dir.join(crate::util::thumbnail_path(&item.id, size, "webp"));
|
||||
if !path.is_file() {
|
||||
return Ok(json!({"success": false, "error": "thumbnail_not_available"}));
|
||||
}
|
||||
let encoded = base64::engine::general_purpose::STANDARD.encode(fs::read(path)?);
|
||||
Ok(json!({
|
||||
"success": true,
|
||||
"media": item,
|
||||
"data_url": format!("data:image/webp;base64,{encoded}"),
|
||||
}))
|
||||
}
|
||||
|
||||
fn post_links(
|
||||
conn: &Connection,
|
||||
project_id: &str,
|
||||
arguments: &Value,
|
||||
incoming: bool,
|
||||
) -> EngineResult<Value> {
|
||||
let id = required_id(arguments, "post_id", "postId")?;
|
||||
let source = post::get_post_by_id(conn, id)?;
|
||||
ensure_project(&source.project_id, project_id)?;
|
||||
let links = if incoming {
|
||||
post_link::list_links_by_target(conn, id)?
|
||||
} else {
|
||||
post_link::list_links_by_source(conn, id)?
|
||||
};
|
||||
let mut items = Vec::with_capacity(links.len());
|
||||
for link in links {
|
||||
let linked_id = if incoming {
|
||||
&link.source_post_id
|
||||
} else {
|
||||
&link.target_post_id
|
||||
};
|
||||
let linked = post::get_post_by_id(conn, linked_id)?;
|
||||
ensure_project(&linked.project_id, project_id)?;
|
||||
items.push(json!({
|
||||
"post": post_summary(&linked),
|
||||
"link_text": link.link_text,
|
||||
}));
|
||||
}
|
||||
if incoming {
|
||||
Ok(json!({"success": true, "post_id": id, "linked_by": items}))
|
||||
} else {
|
||||
Ok(json!({"success": true, "post_id": id, "links_to": items}))
|
||||
}
|
||||
}
|
||||
|
||||
fn linked_media(conn: &Connection, project_id: &str, arguments: &Value) -> EngineResult<Value> {
|
||||
let id = required_id(arguments, "post_id", "postId")?;
|
||||
let item = post::get_post_by_id(conn, id)?;
|
||||
ensure_project(&item.project_id, project_id)?;
|
||||
let mut items = Vec::new();
|
||||
for link in post_media::list_post_media_by_post(conn, id)? {
|
||||
ensure_project(&link.project_id, project_id)?;
|
||||
let item = media::get_media_by_id(conn, &link.media_id)?;
|
||||
ensure_project(&item.project_id, project_id)?;
|
||||
items.push(json!({"media": item, "sort_order": link.sort_order}));
|
||||
}
|
||||
Ok(json!({"success": true, "post_id": id, "media": items}))
|
||||
}
|
||||
|
||||
fn linked_posts(conn: &Connection, project_id: &str, arguments: &Value) -> EngineResult<Value> {
|
||||
let id = required_id(arguments, "media_id", "mediaId")?;
|
||||
let item = media::get_media_by_id(conn, id)?;
|
||||
ensure_project(&item.project_id, project_id)?;
|
||||
let mut items = Vec::new();
|
||||
for link in post_media::list_post_media_by_media(conn, id)? {
|
||||
ensure_project(&link.project_id, project_id)?;
|
||||
let item = post::get_post_by_id(conn, &link.post_id)?;
|
||||
ensure_project(&item.project_id, project_id)?;
|
||||
items.push(json!({"post": post_summary(&item), "sort_order": link.sort_order}));
|
||||
}
|
||||
Ok(json!({"success": true, "media_id": id, "posts": items}))
|
||||
}
|
||||
|
||||
fn counted_terms(conn: &Connection, project_id: &str, tags: bool) -> EngineResult<Value> {
|
||||
let mut counts = BTreeMap::<String, usize>::new();
|
||||
for item in post::list_posts_by_project(conn, project_id)? {
|
||||
for term in if tags { &item.tags } else { &item.categories } {
|
||||
*counts.entry(term.clone()).or_default() += 1;
|
||||
}
|
||||
}
|
||||
let values = counts
|
||||
.into_iter()
|
||||
.map(|(name, count)| json!({"name": name, "count": count}))
|
||||
.collect::<Vec<_>>();
|
||||
Ok(if tags {
|
||||
json!({"tags": values, "count": values.len()})
|
||||
} else {
|
||||
json!({"categories": values, "count": values.len()})
|
||||
})
|
||||
}
|
||||
|
||||
fn navigate(arguments: &Value) -> EngineResult<Value> {
|
||||
let action = arguments.get("action").and_then(Value::as_str);
|
||||
let value = arguments
|
||||
.get("value")
|
||||
.or_else(|| arguments.get("entity_id"))
|
||||
.or_else(|| arguments.get("entityId"))
|
||||
.and_then(Value::as_str);
|
||||
let (destination, entity_id) = match action {
|
||||
Some("open_post" | "openPost") => ("posts", required_navigation_value(value, "post")?),
|
||||
Some("open_media" | "openMedia") => ("media", required_navigation_value(value, "media")?),
|
||||
Some("open_chat" | "openChat") => ("chat", required_navigation_value(value, "chat")?),
|
||||
Some("open_settings" | "openSettings") => ("settings", None),
|
||||
Some("switch_view" | "switchView") => {
|
||||
(required_navigation_value(value, "view")?.unwrap(), None)
|
||||
}
|
||||
Some("toggle_sidebar" | "toggleSidebar") => ("toggle_sidebar", None),
|
||||
Some("toggle_panel" | "togglePanel") => ("toggle_panel", None),
|
||||
Some("toggle_assistant_sidebar" | "toggleAssistantSidebar") => {
|
||||
("toggle_assistant_sidebar", None)
|
||||
}
|
||||
Some(action) => {
|
||||
return Err(EngineError::Validation(format!(
|
||||
"unsupported navigation action: {action}"
|
||||
)));
|
||||
}
|
||||
None => (required_str(arguments, "destination")?, value),
|
||||
};
|
||||
if ![
|
||||
"posts",
|
||||
"pages",
|
||||
"media",
|
||||
"templates",
|
||||
"scripts",
|
||||
"tags",
|
||||
"chat",
|
||||
"import",
|
||||
"git",
|
||||
"settings",
|
||||
"toggle_sidebar",
|
||||
"toggle_panel",
|
||||
"toggle_assistant_sidebar",
|
||||
]
|
||||
.contains(&destination)
|
||||
{
|
||||
return Err(EngineError::Validation(format!(
|
||||
"unsupported navigation destination: {destination}"
|
||||
)));
|
||||
}
|
||||
Ok(json!({
|
||||
"success": true,
|
||||
"navigation": {
|
||||
"destination": destination,
|
||||
"entity_id": entity_id,
|
||||
}
|
||||
}))
|
||||
}
|
||||
|
||||
fn post_detail(data_dir: &Path, item: crate::model::Post) -> EngineResult<Value> {
|
||||
let body = post_body(data_dir, &item)?;
|
||||
Ok(json!({"success": true, "post": item, "body": body}))
|
||||
}
|
||||
|
||||
fn post_body(data_dir: &Path, item: &crate::model::Post) -> EngineResult<String> {
|
||||
if let Some(content) = item.content.as_deref() {
|
||||
return Ok(content.to_string());
|
||||
}
|
||||
if item.file_path.is_empty() {
|
||||
return Ok(String::new());
|
||||
}
|
||||
let raw = fs::read_to_string(data_dir.join(&item.file_path))?;
|
||||
let (_, body) = read_post_file(&raw)
|
||||
.map_err(|error| EngineError::Parse(format!("invalid post file: {error}")))?;
|
||||
Ok(body)
|
||||
}
|
||||
|
||||
fn post_summary(item: &crate::model::Post) -> Value {
|
||||
json!({
|
||||
"id": item.id, "title": item.title, "slug": item.slug,
|
||||
"excerpt": item.excerpt, "status": item.status, "tags": item.tags,
|
||||
"categories": item.categories, "created_at": item.created_at,
|
||||
"updated_at": item.updated_at,
|
||||
})
|
||||
}
|
||||
|
||||
fn spec(name: &str, description: &str, properties: Value) -> Value {
|
||||
let required = properties
|
||||
.as_object()
|
||||
.into_iter()
|
||||
.flat_map(|values| values.iter())
|
||||
.filter(|(_, schema)| !schema.get("type").is_some_and(Value::is_array))
|
||||
.filter(|(name, _)| {
|
||||
matches!(
|
||||
name.as_str(),
|
||||
"term"
|
||||
| "query"
|
||||
| "post_id"
|
||||
| "slug"
|
||||
| "media_id"
|
||||
| "template_id"
|
||||
| "script_id"
|
||||
| "destination"
|
||||
)
|
||||
})
|
||||
.map(|(name, _)| Value::String(name.clone()))
|
||||
.collect::<Vec<_>>();
|
||||
let required = if name == "navigate" {
|
||||
Vec::new()
|
||||
} else {
|
||||
required
|
||||
};
|
||||
json!({
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": name,
|
||||
"description": description,
|
||||
"parameters": {
|
||||
"type": "object",
|
||||
"properties": properties,
|
||||
"required": required,
|
||||
"additionalProperties": false,
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
fn required_navigation_value<'a>(
|
||||
value: Option<&'a str>,
|
||||
target: &str,
|
||||
) -> EngineResult<Option<&'a str>> {
|
||||
value
|
||||
.filter(|value| !value.trim().is_empty())
|
||||
.map(Some)
|
||||
.ok_or_else(|| {
|
||||
EngineError::Validation(format!("navigation {target} identifier is required"))
|
||||
})
|
||||
}
|
||||
|
||||
fn required_str<'a>(arguments: &'a Value, key: &str) -> EngineResult<&'a str> {
|
||||
arguments
|
||||
.get(key)
|
||||
.and_then(Value::as_str)
|
||||
.filter(|value| !value.trim().is_empty())
|
||||
.ok_or_else(|| EngineError::Validation(format!("tool argument {key} is required")))
|
||||
}
|
||||
|
||||
fn required_id<'a>(arguments: &'a Value, snake: &str, camel: &str) -> EngineResult<&'a str> {
|
||||
arguments
|
||||
.get(snake)
|
||||
.or_else(|| arguments.get(camel))
|
||||
.and_then(Value::as_str)
|
||||
.filter(|value| !value.trim().is_empty())
|
||||
.ok_or_else(|| EngineError::Validation(format!("tool argument {snake} is required")))
|
||||
}
|
||||
|
||||
fn ensure_project(actual: &str, expected: &str) -> EngineResult<()> {
|
||||
if actual == expected {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(EngineError::NotFound("project entity".to_string()))
|
||||
}
|
||||
}
|
||||
|
||||
fn limit(arguments: &Value) -> usize {
|
||||
arguments
|
||||
.get("limit")
|
||||
.and_then(Value::as_u64)
|
||||
.unwrap_or(25)
|
||||
.clamp(1, 100) as usize
|
||||
}
|
||||
|
||||
fn contains_case_insensitive(values: &[String], needle: &str) -> bool {
|
||||
values
|
||||
.iter()
|
||||
.any(|value| value.eq_ignore_ascii_case(needle))
|
||||
}
|
||||
|
||||
fn optional_string_array(arguments: &Value, key: &str) -> EngineResult<Option<Vec<String>>> {
|
||||
let Some(value) = arguments.get(key) else {
|
||||
return Ok(None);
|
||||
};
|
||||
let values = value
|
||||
.as_array()
|
||||
.ok_or_else(|| EngineError::Validation(format!("tool argument {key} must be an array")))?
|
||||
.iter()
|
||||
.map(|value| {
|
||||
value.as_str().map(str::to_string).ok_or_else(|| {
|
||||
EngineError::Validation(format!("tool argument {key} must contain strings"))
|
||||
})
|
||||
})
|
||||
.collect::<EngineResult<Vec<_>>>()?;
|
||||
Ok(Some(values))
|
||||
}
|
||||
|
||||
fn optional_nullable_str<'a>(
|
||||
arguments: &'a Value,
|
||||
key: &str,
|
||||
) -> EngineResult<Option<Option<&'a str>>> {
|
||||
match arguments.get(key) {
|
||||
None => Ok(None),
|
||||
Some(Value::Null) => Ok(Some(None)),
|
||||
Some(Value::String(value)) => Ok(Some(Some(value))),
|
||||
Some(_) => Err(EngineError::Validation(format!(
|
||||
"tool argument {key} must be a string or null"
|
||||
))),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::db::Database;
|
||||
use crate::db::queries::media::{insert_media, make_test_media};
|
||||
use crate::db::queries::post::{insert_post, make_test_post};
|
||||
use crate::db::queries::post_link::insert_post_link;
|
||||
use crate::db::queries::post_media::link_media;
|
||||
use crate::db::queries::project::{insert_project, make_test_project};
|
||||
use crate::model::{PostLink, PostMedia};
|
||||
|
||||
fn setup() -> Database {
|
||||
let db = Database::open_in_memory().unwrap();
|
||||
db.migrate().unwrap();
|
||||
insert_project(db.conn(), &make_test_project("p1", "blog")).unwrap();
|
||||
insert_post(db.conn(), &make_test_post("source", "p1", "source")).unwrap();
|
||||
insert_post(db.conn(), &make_test_post("target", "p1", "target")).unwrap();
|
||||
insert_media(db.conn(), &make_test_media("media1", "p1")).unwrap();
|
||||
insert_post_link(
|
||||
db.conn(),
|
||||
&PostLink {
|
||||
id: "link1".into(),
|
||||
source_post_id: "source".into(),
|
||||
target_post_id: "target".into(),
|
||||
link_text: Some("read next".into()),
|
||||
created_at: 1,
|
||||
},
|
||||
)
|
||||
.unwrap();
|
||||
link_media(
|
||||
db.conn(),
|
||||
&PostMedia {
|
||||
id: "post-media1".into(),
|
||||
project_id: "p1".into(),
|
||||
post_id: "source".into(),
|
||||
media_id: "media1".into(),
|
||||
sort_order: 3,
|
||||
created_at: 1,
|
||||
},
|
||||
)
|
||||
.unwrap();
|
||||
db
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn relationship_tools_return_project_entities() {
|
||||
let db = setup();
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let outlinks = execute(
|
||||
db.conn(),
|
||||
dir.path(),
|
||||
"p1",
|
||||
"get_post_outlinks",
|
||||
&json!({"post_id": "source"}),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(outlinks["links_to"][0]["post"]["id"], "target");
|
||||
assert_eq!(outlinks["links_to"][0]["link_text"], "read next");
|
||||
|
||||
let backlinks = execute(
|
||||
db.conn(),
|
||||
dir.path(),
|
||||
"p1",
|
||||
"get_post_backlinks",
|
||||
&json!({"post_id": "target"}),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(backlinks["linked_by"][0]["post"]["id"], "source");
|
||||
|
||||
let post_media = execute(
|
||||
db.conn(),
|
||||
dir.path(),
|
||||
"p1",
|
||||
"get_post_media",
|
||||
&json!({"post_id": "source"}),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(post_media["media"][0]["media"]["id"], "media1");
|
||||
assert_eq!(post_media["media"][0]["sort_order"], 3);
|
||||
|
||||
let media_posts = execute(
|
||||
db.conn(),
|
||||
dir.path(),
|
||||
"p1",
|
||||
"get_media_posts",
|
||||
&json!({"media_id": "media1"}),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(media_posts["posts"][0]["post"]["id"], "source");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn view_image_is_bounded_to_generated_image_thumbnails() {
|
||||
let db = setup();
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let relative = crate::util::thumbnail_path("media1", "medium", "webp");
|
||||
let path = dir.path().join(relative);
|
||||
fs::create_dir_all(path.parent().unwrap()).unwrap();
|
||||
fs::write(&path, b"thumbnail").unwrap();
|
||||
|
||||
let result = execute(
|
||||
db.conn(),
|
||||
dir.path(),
|
||||
"p1",
|
||||
"view_image",
|
||||
&json!({"media_id": "media1", "size": "medium"}),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(result["success"], true);
|
||||
assert_eq!(result["data_url"], "data:image/webp;base64,dGh1bWJuYWls");
|
||||
|
||||
let invalid = execute(
|
||||
db.conn(),
|
||||
dir.path(),
|
||||
"p1",
|
||||
"view_image",
|
||||
&json!({"media_id": "media1", "size": "original"}),
|
||||
);
|
||||
assert!(matches!(invalid, Err(EngineError::Validation(_))));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user