624 lines
20 KiB
Rust
624 lines
20 KiB
Rust
|
use crate::ai_agents::AiAgentStreamEvent;
|
||
|
|
use crate::ai_models::{AiModelProviderKind, AiModelStreamRequest};
|
||
|
|
use std::path::{Path, PathBuf};
|
||
|
|
|
||
|
|
const CREATE_NOTE_TOOL_NAME: &str = "create_note";
|
||
|
|
const CREATE_NOTE_TOOL_JSON: &str = r#"{
|
||
|
|
"type": "function",
|
||
|
|
"function": {
|
||
|
|
"name": "create_note",
|
||
|
|
"description": "Create a new markdown note inside the active Tolaria vault without overwriting existing files.",
|
||
|
|
"parameters": {
|
||
|
|
"type": "object",
|
||
|
|
"properties": {
|
||
|
|
"path": {
|
||
|
|
"type": "string",
|
||
|
|
"description": "Relative path inside the vault, or an absolute path inside the active vault. Must end in .md."
|
||
|
|
},
|
||
|
|
"content": {
|
||
|
|
"type": "string",
|
||
|
|
"description": "Full markdown note content, including YAML frontmatter and H1 when needed."
|
||
|
|
},
|
||
|
|
"title": {
|
||
|
|
"type": "string",
|
||
|
|
"description": "Optional title used only when content is omitted."
|
||
|
|
},
|
||
|
|
"type": {
|
||
|
|
"type": "string",
|
||
|
|
"description": "Optional note type used only when content is omitted."
|
||
|
|
},
|
||
|
|
"is_a": {
|
||
|
|
"type": "string",
|
||
|
|
"description": "Legacy alias for type, used only when content is omitted."
|
||
|
|
},
|
||
|
|
"vaultPath": {
|
||
|
|
"type": "string",
|
||
|
|
"description": "Optional target vault root when multiple vaults are active."
|
||
|
|
}
|
||
|
|
},
|
||
|
|
"required": ["path"],
|
||
|
|
"additionalProperties": false
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}"#;
|
||
|
|
|
||
|
|
struct OpenAiToolCall {
|
||
|
|
id: String,
|
||
|
|
name: String,
|
||
|
|
arguments: serde_json::Value,
|
||
|
|
raw_arguments: String,
|
||
|
|
}
|
||
|
|
|
||
|
|
struct CreatedNoteToolResult {
|
||
|
|
summary: String,
|
||
|
|
output: String,
|
||
|
|
}
|
||
|
|
|
||
|
|
pub(crate) fn openai_chat_payload(request: &AiModelStreamRequest) -> serde_json::Value {
|
||
|
|
let mut payload = serde_json::json!({
|
||
|
|
"model": request.model_id,
|
||
|
|
"messages": openai_chat_messages(request),
|
||
|
|
"stream": false
|
||
|
|
});
|
||
|
|
if should_offer_openai_tools(request) {
|
||
|
|
payload["tools"] = serde_json::Value::Array(vec![openai_create_note_tool()]);
|
||
|
|
payload["tool_choice"] = serde_json::Value::String("auto".into());
|
||
|
|
}
|
||
|
|
payload
|
||
|
|
}
|
||
|
|
|
||
|
|
pub(crate) fn execute_openai_tool_calls<F>(
|
||
|
|
request: &AiModelStreamRequest,
|
||
|
|
json: &serde_json::Value,
|
||
|
|
emit: F,
|
||
|
|
) -> Result<Option<String>, String>
|
||
|
|
where
|
||
|
|
F: FnMut(AiAgentStreamEvent),
|
||
|
|
{
|
||
|
|
let tool_calls = openai_tool_calls(json)?;
|
||
|
|
if tool_calls.is_empty() {
|
||
|
|
return Ok(None);
|
||
|
|
}
|
||
|
|
run_openai_tool_calls(request, &tool_calls, emit).map(Some)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn openai_chat_messages(request: &AiModelStreamRequest) -> Vec<serde_json::Value> {
|
||
|
|
let mut messages = Vec::new();
|
||
|
|
if let Some(system_prompt) = non_empty_option(request.system_prompt.as_deref()) {
|
||
|
|
messages.push(serde_json::json!({ "role": "system", "content": system_prompt }));
|
||
|
|
}
|
||
|
|
messages.push(serde_json::json!({ "role": "user", "content": request.message }));
|
||
|
|
messages
|
||
|
|
}
|
||
|
|
|
||
|
|
fn should_offer_openai_tools(request: &AiModelStreamRequest) -> bool {
|
||
|
|
let has_active_vault = non_empty_option(request.vault_path.as_deref()).is_some();
|
||
|
|
has_active_vault
|
||
|
|
&& (request.provider.kind == AiModelProviderKind::OpenAi
|
||
|
|
|| selected_model_supports_tools(request))
|
||
|
|
}
|
||
|
|
|
||
|
|
fn selected_model_supports_tools(request: &AiModelStreamRequest) -> bool {
|
||
|
|
request
|
||
|
|
.provider
|
||
|
|
.models
|
||
|
|
.iter()
|
||
|
|
.find(|model| model.id == request.model_id)
|
||
|
|
.is_some_and(|model| model.capabilities.tools)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn openai_create_note_tool() -> serde_json::Value {
|
||
|
|
serde_json::from_str(CREATE_NOTE_TOOL_JSON).expect("create_note tool schema must be valid JSON")
|
||
|
|
}
|
||
|
|
|
||
|
|
fn run_openai_tool_calls<F>(
|
||
|
|
request: &AiModelStreamRequest,
|
||
|
|
tool_calls: &[OpenAiToolCall],
|
||
|
|
mut emit: F,
|
||
|
|
) -> Result<String, String>
|
||
|
|
where
|
||
|
|
F: FnMut(AiAgentStreamEvent),
|
||
|
|
{
|
||
|
|
let mut summaries = Vec::new();
|
||
|
|
for tool_call in tool_calls {
|
||
|
|
summaries.push(execute_openai_tool_call(request, tool_call, &mut emit)?);
|
||
|
|
}
|
||
|
|
Ok(summaries.join("\n"))
|
||
|
|
}
|
||
|
|
|
||
|
|
fn execute_openai_tool_call<F>(
|
||
|
|
request: &AiModelStreamRequest,
|
||
|
|
tool_call: &OpenAiToolCall,
|
||
|
|
emit: &mut F,
|
||
|
|
) -> Result<String, String>
|
||
|
|
where
|
||
|
|
F: FnMut(AiAgentStreamEvent),
|
||
|
|
{
|
||
|
|
if tool_call.name != CREATE_NOTE_TOOL_NAME {
|
||
|
|
return Err(format!(
|
||
|
|
"AI provider requested unsupported tool: {}",
|
||
|
|
tool_call.name
|
||
|
|
));
|
||
|
|
}
|
||
|
|
|
||
|
|
emit(AiAgentStreamEvent::ToolStart {
|
||
|
|
tool_name: CREATE_NOTE_TOOL_NAME.into(),
|
||
|
|
tool_id: tool_call.id.clone(),
|
||
|
|
input: Some(tool_call.raw_arguments.clone()),
|
||
|
|
});
|
||
|
|
|
||
|
|
match create_note_from_tool_args(request, &tool_call.arguments) {
|
||
|
|
Ok(result) => {
|
||
|
|
emit(AiAgentStreamEvent::ToolDone {
|
||
|
|
tool_id: tool_call.id.clone(),
|
||
|
|
output: Some(result.output),
|
||
|
|
});
|
||
|
|
Ok(result.summary)
|
||
|
|
}
|
||
|
|
Err(error) => {
|
||
|
|
emit(AiAgentStreamEvent::ToolDone {
|
||
|
|
tool_id: tool_call.id.clone(),
|
||
|
|
output: Some(format!("Error: {error}")),
|
||
|
|
});
|
||
|
|
Err(error)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn openai_tool_calls(json: &serde_json::Value) -> Result<Vec<OpenAiToolCall>, String> {
|
||
|
|
let Some(calls) = json["choices"][0]["message"]["tool_calls"].as_array() else {
|
||
|
|
return Ok(Vec::new());
|
||
|
|
};
|
||
|
|
|
||
|
|
calls
|
||
|
|
.iter()
|
||
|
|
.enumerate()
|
||
|
|
.map(|(index, call)| openai_tool_call(index, call))
|
||
|
|
.collect()
|
||
|
|
}
|
||
|
|
|
||
|
|
fn openai_tool_call(index: usize, call: &serde_json::Value) -> Result<OpenAiToolCall, String> {
|
||
|
|
let function = &call["function"];
|
||
|
|
let name = function["name"]
|
||
|
|
.as_str()
|
||
|
|
.ok_or_else(|| "AI provider tool call did not include a function name.".to_string())?
|
||
|
|
.to_string();
|
||
|
|
let (arguments, raw_arguments) = parse_tool_arguments(&function["arguments"])?;
|
||
|
|
let id = call["id"]
|
||
|
|
.as_str()
|
||
|
|
.map(str::to_string)
|
||
|
|
.unwrap_or_else(|| format!("tool_call_{index}"));
|
||
|
|
Ok(OpenAiToolCall {
|
||
|
|
id,
|
||
|
|
name,
|
||
|
|
arguments,
|
||
|
|
raw_arguments,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
fn parse_tool_arguments(value: &serde_json::Value) -> Result<(serde_json::Value, String), String> {
|
||
|
|
if let Some(raw) = value.as_str() {
|
||
|
|
let parsed = serde_json::from_str(raw)
|
||
|
|
.map_err(|error| format!("Failed to parse AI tool arguments: {error}"))?;
|
||
|
|
return Ok((parsed, raw.to_string()));
|
||
|
|
}
|
||
|
|
if value.is_object() {
|
||
|
|
let raw = serde_json::to_string(value)
|
||
|
|
.map_err(|error| format!("Failed to serialize AI tool arguments: {error}"))?;
|
||
|
|
return Ok((value.clone(), raw));
|
||
|
|
}
|
||
|
|
Ok((serde_json::json!({}), "{}".into()))
|
||
|
|
}
|
||
|
|
|
||
|
|
fn create_note_from_tool_args(
|
||
|
|
request: &AiModelStreamRequest,
|
||
|
|
args: &serde_json::Value,
|
||
|
|
) -> Result<CreatedNoteToolResult, String> {
|
||
|
|
let note_path = required_tool_string(args, "path")?;
|
||
|
|
let content = create_note_tool_content(args, note_path);
|
||
|
|
let vault_path = tool_vault_path(request, args)?;
|
||
|
|
crate::commands::create_note_content(
|
||
|
|
PathBuf::from(note_path),
|
||
|
|
content,
|
||
|
|
Some(PathBuf::from(vault_path)),
|
||
|
|
)?;
|
||
|
|
let output = serde_json::json!({
|
||
|
|
"path": note_path,
|
||
|
|
"vaultPath": vault_path,
|
||
|
|
})
|
||
|
|
.to_string();
|
||
|
|
Ok(CreatedNoteToolResult {
|
||
|
|
summary: format!("Created note: {note_path}"),
|
||
|
|
output,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
fn tool_vault_path<'a>(
|
||
|
|
request: &'a AiModelStreamRequest,
|
||
|
|
args: &'a serde_json::Value,
|
||
|
|
) -> Result<&'a str, String> {
|
||
|
|
if let Some(vault_path) = string_arg(args, "vaultPath") {
|
||
|
|
return active_tool_vault_path(request, vault_path);
|
||
|
|
}
|
||
|
|
request
|
||
|
|
.vault_path
|
||
|
|
.as_deref()
|
||
|
|
.and_then(non_empty_str)
|
||
|
|
.ok_or_else(|| "No active vault is available for create_note.".to_string())
|
||
|
|
}
|
||
|
|
|
||
|
|
fn active_tool_vault_path<'a>(
|
||
|
|
request: &'a AiModelStreamRequest,
|
||
|
|
vault_path: &'a str,
|
||
|
|
) -> Result<&'a str, String> {
|
||
|
|
if active_vault_paths(request).any(|active| active == vault_path) {
|
||
|
|
Ok(vault_path)
|
||
|
|
} else {
|
||
|
|
Err(format!("Vault is not active in Tolaria: {vault_path}"))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn active_vault_paths(request: &AiModelStreamRequest) -> impl Iterator<Item = &str> {
|
||
|
|
request
|
||
|
|
.vault_path
|
||
|
|
.as_deref()
|
||
|
|
.into_iter()
|
||
|
|
.chain(request.vault_paths.iter().map(String::as_str))
|
||
|
|
.filter_map(non_empty_str)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn create_note_tool_content(args: &serde_json::Value, note_path: &str) -> String {
|
||
|
|
if let Some(content) = content_arg(args, "content") {
|
||
|
|
return content.to_string();
|
||
|
|
}
|
||
|
|
let title = string_arg(args, "title")
|
||
|
|
.map(str::to_string)
|
||
|
|
.unwrap_or_else(|| fallback_note_title(note_path));
|
||
|
|
let note_type = string_arg(args, "type")
|
||
|
|
.or_else(|| string_arg(args, "is_a"))
|
||
|
|
.unwrap_or("Note");
|
||
|
|
let note_type_yaml = serde_json::to_string(note_type).unwrap_or_else(|_| "\"Note\"".into());
|
||
|
|
format!("---\ntype: {note_type_yaml}\n---\n\n# {title}\n")
|
||
|
|
}
|
||
|
|
|
||
|
|
fn fallback_note_title(note_path: &str) -> String {
|
||
|
|
let normalized = note_path.replace('\\', "/");
|
||
|
|
Path::new(&normalized)
|
||
|
|
.file_stem()
|
||
|
|
.and_then(|stem| stem.to_str())
|
||
|
|
.filter(|title| !title.trim().is_empty())
|
||
|
|
.unwrap_or("Untitled")
|
||
|
|
.to_string()
|
||
|
|
}
|
||
|
|
|
||
|
|
fn required_tool_string<'a>(args: &'a serde_json::Value, key: &str) -> Result<&'a str, String> {
|
||
|
|
string_arg(args, key).ok_or_else(|| format!("create_note requires {key}."))
|
||
|
|
}
|
||
|
|
|
||
|
|
fn string_arg<'a>(args: &'a serde_json::Value, key: &str) -> Option<&'a str> {
|
||
|
|
args[key].as_str().and_then(non_empty_str)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn content_arg<'a>(args: &'a serde_json::Value, key: &str) -> Option<&'a str> {
|
||
|
|
args[key]
|
||
|
|
.as_str()
|
||
|
|
.filter(|content| !content.trim().is_empty())
|
||
|
|
}
|
||
|
|
|
||
|
|
fn non_empty_option(value: Option<&str>) -> Option<&str> {
|
||
|
|
value.map(str::trim).filter(|value| !value.is_empty())
|
||
|
|
}
|
||
|
|
|
||
|
|
fn non_empty_str(value: &str) -> Option<&str> {
|
||
|
|
non_empty_option(Some(value))
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(test)]
|
||
|
|
mod tests {
|
||
|
|
use super::*;
|
||
|
|
use crate::ai_models::{
|
||
|
|
AiModelApiKeyStorage, AiModelCapabilities, AiModelDefinition, AiModelProvider,
|
||
|
|
};
|
||
|
|
use serde_json::json;
|
||
|
|
use std::fs;
|
||
|
|
|
||
|
|
const CREATED_NOTE_PATH: &str = "nota-longa-teste-gerada-2.md";
|
||
|
|
const CREATED_NOTE_CONTENT: &str = "---\ntype: Note\n---\n\n# Nota longa de teste - gerada 2\n";
|
||
|
|
|
||
|
|
fn request(vault_path: String) -> AiModelStreamRequest {
|
||
|
|
request_with_provider(provider(), Some(vault_path), Vec::new())
|
||
|
|
}
|
||
|
|
|
||
|
|
fn request_with_provider(
|
||
|
|
provider: AiModelProvider,
|
||
|
|
vault_path: Option<String>,
|
||
|
|
vault_paths: Vec<String>,
|
||
|
|
) -> AiModelStreamRequest {
|
||
|
|
AiModelStreamRequest {
|
||
|
|
provider,
|
||
|
|
model_id: "gpt-5-nano".into(),
|
||
|
|
message: "Create the note".into(),
|
||
|
|
system_prompt: Some("Use create_note for new notes.".into()),
|
||
|
|
vault_path,
|
||
|
|
vault_paths,
|
||
|
|
api_key_override: None,
|
||
|
|
event_name: None,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn provider() -> AiModelProvider {
|
||
|
|
AiModelProvider {
|
||
|
|
id: "openai".into(),
|
||
|
|
name: "OpenAI".into(),
|
||
|
|
kind: AiModelProviderKind::OpenAi,
|
||
|
|
base_url: Some("https://api.openai.com/v1".into()),
|
||
|
|
api_key_storage: Some(AiModelApiKeyStorage::LocalFile),
|
||
|
|
api_key_env_var: None,
|
||
|
|
headers: None,
|
||
|
|
models: vec![AiModelDefinition {
|
||
|
|
id: "gpt-5-nano".into(),
|
||
|
|
display_name: None,
|
||
|
|
context_window: None,
|
||
|
|
max_output_tokens: None,
|
||
|
|
capabilities: AiModelCapabilities {
|
||
|
|
streaming: false,
|
||
|
|
tools: false,
|
||
|
|
vision: false,
|
||
|
|
json_mode: false,
|
||
|
|
reasoning: false,
|
||
|
|
},
|
||
|
|
}],
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn create_note_response() -> serde_json::Value {
|
||
|
|
tool_call_response(json!({
|
||
|
|
"id": "call_create",
|
||
|
|
"function": {
|
||
|
|
"name": CREATE_NOTE_TOOL_NAME,
|
||
|
|
"arguments": serde_json::to_string(&json!({
|
||
|
|
"path": CREATED_NOTE_PATH,
|
||
|
|
"content": CREATED_NOTE_CONTENT
|
||
|
|
})).unwrap()
|
||
|
|
}
|
||
|
|
}))
|
||
|
|
}
|
||
|
|
|
||
|
|
fn tool_call_response(tool_call: serde_json::Value) -> serde_json::Value {
|
||
|
|
json!({
|
||
|
|
"choices": [{
|
||
|
|
"message": {
|
||
|
|
"tool_calls": [tool_call]
|
||
|
|
}
|
||
|
|
}]
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
fn create_note_response_with_args(arguments: serde_json::Value) -> serde_json::Value {
|
||
|
|
tool_call_response(json!({
|
||
|
|
"function": {
|
||
|
|
"name": CREATE_NOTE_TOOL_NAME,
|
||
|
|
"arguments": arguments,
|
||
|
|
}
|
||
|
|
}))
|
||
|
|
}
|
||
|
|
|
||
|
|
fn create_note_error(arguments: serde_json::Value) -> String {
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let request = request(dir.path().to_string_lossy().into_owned());
|
||
|
|
|
||
|
|
execute_openai_tool_calls(&request, &create_note_response_with_args(arguments), |_| {})
|
||
|
|
.unwrap_err()
|
||
|
|
}
|
||
|
|
|
||
|
|
fn assert_note_created(vault_path: &Path) {
|
||
|
|
let actual = fs::read_to_string(vault_path.join(CREATED_NOTE_PATH)).unwrap();
|
||
|
|
assert_eq!(actual, CREATED_NOTE_CONTENT);
|
||
|
|
}
|
||
|
|
|
||
|
|
fn assert_summary(summary: Option<String>) {
|
||
|
|
assert_eq!(
|
||
|
|
summary.as_deref(),
|
||
|
|
Some("Created note: nota-longa-teste-gerada-2.md"),
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
fn assert_tool_events(events: &[AiAgentStreamEvent]) {
|
||
|
|
assert!(matches!(
|
||
|
|
&events[0],
|
||
|
|
AiAgentStreamEvent::ToolStart { tool_name, tool_id, input: Some(input) }
|
||
|
|
if tool_name == CREATE_NOTE_TOOL_NAME && tool_id == "call_create" && input.contains(CREATED_NOTE_PATH)
|
||
|
|
));
|
||
|
|
assert!(matches!(
|
||
|
|
&events[1],
|
||
|
|
AiAgentStreamEvent::ToolDone { tool_id, output: Some(output) }
|
||
|
|
if tool_id == "call_create" && output.contains(CREATED_NOTE_PATH)
|
||
|
|
));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn openai_payload_offers_create_note_when_active_vault_is_loaded() {
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let payload = openai_chat_payload(&request(dir.path().to_string_lossy().into_owned()));
|
||
|
|
|
||
|
|
assert!(payload["tools"][0]["function"]["name"] == CREATE_NOTE_TOOL_NAME);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn openai_payload_offers_create_note_for_tool_capable_custom_models() {
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let mut provider = provider();
|
||
|
|
provider.kind = AiModelProviderKind::OpenAiCompatible;
|
||
|
|
provider.models[0].capabilities.tools = true;
|
||
|
|
let request = request_with_provider(
|
||
|
|
provider,
|
||
|
|
Some(dir.path().to_string_lossy().into_owned()),
|
||
|
|
vec![],
|
||
|
|
);
|
||
|
|
|
||
|
|
let payload = openai_chat_payload(&request);
|
||
|
|
|
||
|
|
assert!(payload["tools"][0]["function"]["name"] == CREATE_NOTE_TOOL_NAME);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn openai_payload_skips_create_note_when_no_active_vault_is_loaded() {
|
||
|
|
let payload = openai_chat_payload(&request_with_provider(provider(), None, Vec::new()));
|
||
|
|
|
||
|
|
assert!(payload.get("tools").is_none());
|
||
|
|
assert!(payload.get("tool_choice").is_none());
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn execute_openai_tool_calls_returns_none_without_tool_calls() {
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let request = request(dir.path().to_string_lossy().into_owned());
|
||
|
|
|
||
|
|
let summary = execute_openai_tool_calls(
|
||
|
|
&request,
|
||
|
|
&json!({ "choices": [{ "message": { "content": "No tools" } }] }),
|
||
|
|
|_| {},
|
||
|
|
)
|
||
|
|
.unwrap();
|
||
|
|
|
||
|
|
assert_eq!(summary, None);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn executes_openai_create_note_tool_call_inside_active_vault() {
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let request = request(dir.path().to_string_lossy().into_owned());
|
||
|
|
let mut events = Vec::new();
|
||
|
|
|
||
|
|
let summary = execute_openai_tool_calls(&request, &create_note_response(), |event| {
|
||
|
|
events.push(event)
|
||
|
|
})
|
||
|
|
.unwrap();
|
||
|
|
|
||
|
|
assert_note_created(dir.path());
|
||
|
|
assert_summary(summary);
|
||
|
|
assert_tool_events(&events);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn executes_openai_create_note_with_object_arguments_and_selected_vault() {
|
||
|
|
let primary = tempfile::tempdir().unwrap();
|
||
|
|
let secondary = tempfile::tempdir().unwrap();
|
||
|
|
let secondary_path = secondary.path().to_string_lossy().into_owned();
|
||
|
|
let request = request_with_provider(
|
||
|
|
provider(),
|
||
|
|
Some(primary.path().to_string_lossy().into_owned()),
|
||
|
|
vec![secondary_path.clone()],
|
||
|
|
);
|
||
|
|
let response = tool_call_response(json!({
|
||
|
|
"function": {
|
||
|
|
"name": CREATE_NOTE_TOOL_NAME,
|
||
|
|
"arguments": {
|
||
|
|
"path": "Generated/fallback-note.md",
|
||
|
|
"is_a": "Project",
|
||
|
|
"vaultPath": secondary_path,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}));
|
||
|
|
|
||
|
|
let summary = execute_openai_tool_calls(&request, &response, |_| {}).unwrap();
|
||
|
|
|
||
|
|
assert_eq!(
|
||
|
|
fs::read_to_string(secondary.path().join("Generated/fallback-note.md")).unwrap(),
|
||
|
|
"---\ntype: \"Project\"\n---\n\n# fallback-note\n",
|
||
|
|
);
|
||
|
|
assert_eq!(
|
||
|
|
summary.as_deref(),
|
||
|
|
Some("Created note: Generated/fallback-note.md")
|
||
|
|
);
|
||
|
|
assert!(!primary.path().join("Generated/fallback-note.md").exists());
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn execute_openai_tool_calls_rejects_unsupported_tool_before_running_it() {
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let request = request(dir.path().to_string_lossy().into_owned());
|
||
|
|
let response = tool_call_response(json!({
|
||
|
|
"id": "call_delete",
|
||
|
|
"function": {
|
||
|
|
"name": "delete_note",
|
||
|
|
"arguments": "{}",
|
||
|
|
}
|
||
|
|
}));
|
||
|
|
let mut events = Vec::new();
|
||
|
|
|
||
|
|
let error =
|
||
|
|
execute_openai_tool_calls(&request, &response, |event| events.push(event)).unwrap_err();
|
||
|
|
|
||
|
|
assert_eq!(error, "AI provider requested unsupported tool: delete_note");
|
||
|
|
assert!(events.is_empty());
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn execute_openai_tool_calls_rejects_malformed_arguments() {
|
||
|
|
let error = create_note_error(json!("{not-json"));
|
||
|
|
|
||
|
|
assert!(error.contains("Failed to parse AI tool arguments"));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn execute_openai_tool_calls_treats_non_object_arguments_as_empty() {
|
||
|
|
let error = create_note_error(json!([]));
|
||
|
|
|
||
|
|
assert_eq!(error, "create_note requires path.");
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn execute_openai_tool_calls_rejects_existing_note_without_overwriting() {
|
||
|
|
let dir = tempfile::tempdir().unwrap();
|
||
|
|
let request = request(dir.path().to_string_lossy().into_owned());
|
||
|
|
fs::write(dir.path().join("existing.md"), "# Existing\n").unwrap();
|
||
|
|
let response = tool_call_response(json!({
|
||
|
|
"function": {
|
||
|
|
"name": CREATE_NOTE_TOOL_NAME,
|
||
|
|
"arguments": serde_json::to_string(&json!({
|
||
|
|
"path": "existing.md",
|
||
|
|
"content": "# Replacement\n",
|
||
|
|
})).unwrap(),
|
||
|
|
}
|
||
|
|
}));
|
||
|
|
|
||
|
|
let error = execute_openai_tool_calls(&request, &response, |_| {}).unwrap_err();
|
||
|
|
|
||
|
|
assert!(error.contains("already exists"));
|
||
|
|
assert_eq!(
|
||
|
|
fs::read_to_string(dir.path().join("existing.md")).unwrap(),
|
||
|
|
"# Existing\n",
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn execute_openai_tool_calls_requires_path() {
|
||
|
|
let error = create_note_error(json!("{}"));
|
||
|
|
|
||
|
|
assert_eq!(error, "create_note requires path.");
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn execute_openai_tool_calls_rejects_inactive_explicit_vault() {
|
||
|
|
let active = tempfile::tempdir().unwrap();
|
||
|
|
let inactive = tempfile::tempdir().unwrap();
|
||
|
|
let request = request(active.path().to_string_lossy().into_owned());
|
||
|
|
let response = tool_call_response(json!({
|
||
|
|
"function": {
|
||
|
|
"name": CREATE_NOTE_TOOL_NAME,
|
||
|
|
"arguments": serde_json::to_string(&json!({
|
||
|
|
"path": "inactive.md",
|
||
|
|
"content": "# Inactive\n",
|
||
|
|
"vaultPath": inactive.path().to_string_lossy(),
|
||
|
|
})).unwrap(),
|
||
|
|
}
|
||
|
|
}));
|
||
|
|
|
||
|
|
let error = execute_openai_tool_calls(&request, &response, |_| {}).unwrap_err();
|
||
|
|
|
||
|
|
assert!(error.starts_with("Vault is not active in Tolaria:"));
|
||
|
|
assert!(!inactive.path().join("inactive.md").exists());
|
||
|
|
}
|
||
|
|
}
|