979 lines
36 KiB
Rust
979 lines
36 KiB
Rust
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, chat_surfaces};
|
|
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. Use render tools for structured data, comparisons, and forms; their payloads are native UI data, never HTML or JavaScript.",
|
|
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"}
|
|
}),
|
|
),
|
|
spec(
|
|
"render_card",
|
|
"Render an information card with optional allow-listed actions.",
|
|
json!({
|
|
"title": {"type": "string"}, "subtitle": {"type": "string"}, "body": {"type": "string"},
|
|
"actions": {"type": "array", "items": {"type": "object", "properties": {
|
|
"label": {"type": "string"}, "action": {"type": "string"}, "payload": {"type": "object"}
|
|
}, "required": ["label", "action"]}}
|
|
}),
|
|
),
|
|
spec(
|
|
"render_chart",
|
|
"Render a native chart; heatmap and stacked-bar series use labelled segments.",
|
|
json!({
|
|
"chartType": {"type": "string", "enum": ["bar", "stacked-bar", "line", "area", "pie", "donut", "heatmap"]},
|
|
"chart_type": {"type": "string", "enum": ["bar", "stacked-bar", "line", "area", "pie", "donut", "heatmap"]},
|
|
"title": {"type": "string"},
|
|
"series": {"type": "array", "items": {"type": "object", "properties": {
|
|
"label": {"type": "string"}, "value": {"type": "number"},
|
|
"segments": {"type": "array", "items": {"type": "object", "properties": {
|
|
"label": {"type": "string"}, "value": {"type": "number"}
|
|
}, "required": ["label", "value"]}}
|
|
}, "required": ["label"]}}
|
|
}),
|
|
),
|
|
spec(
|
|
"render_form",
|
|
"Render a native form that submits its current values with an allow-listed action.",
|
|
json!({
|
|
"title": {"type": "string"},
|
|
"fields": {"type": "array", "items": {"type": "object", "properties": {
|
|
"key": {"type": "string"}, "label": {"type": "string"},
|
|
"inputType": {"type": "string", "enum": ["text", "textarea", "select", "checkbox", "date", "number"]},
|
|
"input_type": {"type": "string", "enum": ["text", "textarea", "select", "checkbox", "date", "number"]},
|
|
"placeholder": {"type": "string"}, "defaultValue": {}, "default_value": {}, "required": {"type": "boolean"},
|
|
"options": {"type": "array", "items": {"type": "object", "properties": {
|
|
"label": {"type": "string"}, "value": {"type": "string"}
|
|
}}}
|
|
}, "required": ["key", "label", "inputType"]}},
|
|
"submitLabel": {"type": "string"}, "submit_label": {"type": "string"},
|
|
"submitAction": {"type": "string"}, "submit_action": {"type": "string"}
|
|
}),
|
|
),
|
|
spec(
|
|
"render_list",
|
|
"Render a native list.",
|
|
json!({"title": {"type": "string"}, "items": {"type": "array", "items": {"type": "string"}}}),
|
|
),
|
|
spec(
|
|
"render_metric",
|
|
"Render a prominent metric.",
|
|
json!({"label": {"type": "string"}, "value": {"type": "string"}}),
|
|
),
|
|
spec(
|
|
"render_mindmap",
|
|
"Render a native hierarchical mind map.",
|
|
json!({"title": {"type": "string"}, "nodes": {"type": "array", "items": {"type": "object", "properties": {
|
|
"id": {"type": "string"}, "label": {"type": "string"}, "children": {"type": "array", "items": {"type": "string"}}
|
|
}, "required": ["label"]}}}),
|
|
),
|
|
spec(
|
|
"render_table",
|
|
"Render a native data table.",
|
|
json!({
|
|
"title": {"type": "string"}, "columns": {"type": "array", "items": {"type": "string"}},
|
|
"rows": {"type": "array", "items": {"type": "array", "items": {"type": "string"}}}
|
|
}),
|
|
),
|
|
spec(
|
|
"render_tabs",
|
|
"Render switchable tabs containing nested native surfaces or text.",
|
|
json!({"title": {"type": "string"}, "tabs": {"type": "array", "items": {"type": "object", "properties": {
|
|
"label": {"type": "string"}, "content": {"type": "array", "items": {"type": "object"}}
|
|
}, "required": ["label", "content"]}}}),
|
|
),
|
|
]
|
|
}
|
|
|
|
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),
|
|
name if chat_surfaces::RENDER_TOOL_NAMES.contains(&name) => {
|
|
Ok(chat_surfaces::render_tool_result(name, arguments)
|
|
.expect("render tool allow-list and result builder must stay in sync"))
|
|
}
|
|
_ => 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(_))));
|
|
}
|
|
|
|
#[test]
|
|
fn structured_render_tools_are_advertised_and_return_inert_native_data() {
|
|
let specs = tool_specs();
|
|
let names = specs
|
|
.iter()
|
|
.filter_map(|spec| spec.pointer("/function/name").and_then(Value::as_str))
|
|
.collect::<BTreeSet<_>>();
|
|
for name in chat_surfaces::RENDER_TOOL_NAMES {
|
|
assert!(names.contains(name), "missing tool schema for {name}");
|
|
}
|
|
let chart = specs
|
|
.iter()
|
|
.find(|spec| {
|
|
spec.pointer("/function/name").and_then(Value::as_str) == Some("render_chart")
|
|
})
|
|
.unwrap();
|
|
assert!(
|
|
chart
|
|
.pointer("/function/parameters/properties/chartType")
|
|
.is_some()
|
|
);
|
|
assert!(
|
|
chart
|
|
.pointer("/function/parameters/properties/chart_type")
|
|
.is_some()
|
|
);
|
|
|
|
let db = setup();
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let raw = json!({"title": "<script>alert(1)</script>", "body": "<b>data</b>"});
|
|
let result = execute(db.conn(), dir.path(), "p1", "render_card", &raw).unwrap();
|
|
assert_eq!(result["type"], "card");
|
|
assert_eq!(result["title"], raw["title"]);
|
|
assert_eq!(result["body"], raw["body"]);
|
|
assert!(result.get("html").is_none());
|
|
assert!(result.get("javascript").is_none());
|
|
}
|
|
}
|