tools: each module owns its Tool list, no duplication
Each tool module exports its own tools() returning Vec<Tool>. mod.rs::tools() chains them. Individual _def() and handler functions are pub(super), not exported. Aggregate definitions derived from the Tool lists. - memory: memory_tools(), journal_tools() - channels: tools() - control: tools() - mod.rs: just chains + adds file/bash/web/vision Co-Authored-By: Proof of Concept <poc@bcachefs.org>
This commit is contained in:
ProofOfConcept
Kent Overstreet
parent
aa7511d110
commit
6d6da07f91
4 changed files with 91 additions and 81 deletions
|
|
@ -51,7 +51,16 @@ pub fn definitions() -> Vec<ToolDef> {
|
|||
]
|
||||
}
|
||||
|
||||
// ── Dispatch ───────────────────────────────────────────────────
|
||||
pub fn tools() -> Vec<super::Tool> {
|
||||
use super::Tool;
|
||||
let defs = definitions();
|
||||
vec![
|
||||
Tool { def: defs[0].clone(), handler: |_a, _v| Box::pin(async move { channel_list().await }) },
|
||||
Tool { def: defs[1].clone(), handler: |_a, v| Box::pin(async move { channel_recv(&v).await }) },
|
||||
Tool { def: defs[2].clone(), handler: |_a, v| Box::pin(async move { channel_send(&v).await }) },
|
||||
Tool { def: defs[3].clone(), handler: |_a, _v| Box::pin(async move { channel_notifications().await }) },
|
||||
]
|
||||
}
|
||||
|
||||
// ── Tool implementations ───────────────────────────────────────
|
||||
|
||||
|
|
|
|||
|
|
@ -50,7 +50,26 @@ pub(super) fn yield_to_user(args: &serde_json::Value) -> Result<ToolOutput> {
|
|||
})
|
||||
}
|
||||
|
||||
pub(super) fn definitions() -> Vec<ToolDef> {
|
||||
pub(super) fn tools() -> Vec<super::Tool> {
|
||||
use super::Tool;
|
||||
let defs = definitions();
|
||||
vec![
|
||||
Tool { def: defs[0].clone(), // switch_model
|
||||
handler: |_a, v| Box::pin(async move {
|
||||
let model = v.get("model").and_then(|v| v.as_str()).unwrap_or("");
|
||||
Ok(format!("Switching to model: {}", model))
|
||||
}) },
|
||||
Tool { def: defs[1].clone(), // pause
|
||||
handler: |_a, _v| Box::pin(async { Ok("Pausing autonomous behavior. Only user input will wake you.".into()) }) },
|
||||
Tool { def: defs[2].clone(), // yield_to_user
|
||||
handler: |_a, v| Box::pin(async move {
|
||||
let msg = v.get("message").and_then(|v| v.as_str()).unwrap_or("(yielding to user)");
|
||||
Ok(msg.to_string())
|
||||
}) },
|
||||
]
|
||||
}
|
||||
|
||||
fn definitions() -> Vec<ToolDef> {
|
||||
vec![
|
||||
ToolDef::new(
|
||||
"switch_model",
|
||||
|
|
|
|||
|
|
@ -29,40 +29,55 @@ fn provenance() -> &'static str { "manual" }
|
|||
|
||||
// ── Definitions ────────────────────────────────────────────────
|
||||
|
||||
pub fn definitions() -> Vec<ToolDef> {
|
||||
pub fn memory_tools() -> Vec<super::Tool> {
|
||||
use super::Tool;
|
||||
vec![
|
||||
render_def(), write_def(), search_def(), links_def(),
|
||||
link_set_def(), link_add_def(), used_def(), weight_set_def(),
|
||||
rename_def(), supersede_def(), query_def(), output_def(),
|
||||
Tool { def: render_def(), handler: |_a, v| Box::pin(async move { render(&v) }) },
|
||||
Tool { def: write_def(), handler: |_a, v| Box::pin(async move { write(&v) }) },
|
||||
Tool { def: search_def(), handler: |_a, v| Box::pin(async move { search(&v) }) },
|
||||
Tool { def: links_def(), handler: |_a, v| Box::pin(async move { links(&v) }) },
|
||||
Tool { def: link_set_def(), handler: |_a, v| Box::pin(async move { link_set(&v) }) },
|
||||
Tool { def: link_add_def(), handler: |_a, v| Box::pin(async move { link_add(&v) }) },
|
||||
Tool { def: used_def(), handler: |_a, v| Box::pin(async move { used(&v) }) },
|
||||
Tool { def: weight_set_def(), handler: |_a, v| Box::pin(async move { weight_set(&v) }) },
|
||||
Tool { def: rename_def(), handler: |_a, v| Box::pin(async move { rename(&v) }) },
|
||||
Tool { def: supersede_def(), handler: |_a, v| Box::pin(async move { supersede(&v) }) },
|
||||
Tool { def: query_def(), handler: |_a, v| Box::pin(async move { query(&v) }) },
|
||||
Tool { def: output_def(), handler: |_a, v| Box::pin(async move { output(&v) }) },
|
||||
]
|
||||
}
|
||||
|
||||
pub fn journal_definitions() -> Vec<ToolDef> {
|
||||
vec![journal_tail_def(), journal_new_def(), journal_update_def()]
|
||||
pub fn journal_tools() -> Vec<super::Tool> {
|
||||
use super::Tool;
|
||||
vec![
|
||||
Tool { def: journal_tail_def(), handler: |_a, v| Box::pin(async move { journal_tail(&v) }) },
|
||||
Tool { def: journal_new_def(), handler: |_a, v| Box::pin(async move { journal_new(&v) }) },
|
||||
Tool { def: journal_update_def(), handler: |_a, v| Box::pin(async move { journal_update(&v) }) },
|
||||
]
|
||||
}
|
||||
|
||||
// ── Memory tools ───────────────────────────────────────────────
|
||||
|
||||
pub fn render_def() -> ToolDef {
|
||||
fn render_def() -> ToolDef {
|
||||
ToolDef::new("memory_render",
|
||||
"Read a memory node's content and links.",
|
||||
json!({"type":"object","properties":{"key":{"type":"string","description":"Node key"}},"required":["key"]}))
|
||||
}
|
||||
|
||||
pub fn render(args: &serde_json::Value) -> Result<String> {
|
||||
fn render(args: &serde_json::Value) -> Result<String> {
|
||||
let key = get_str(args, "key")?;
|
||||
Ok(MemoryNode::load(key)
|
||||
.ok_or_else(|| anyhow::anyhow!("node not found: {}", key))?
|
||||
.render())
|
||||
}
|
||||
|
||||
pub fn write_def() -> ToolDef {
|
||||
fn write_def() -> ToolDef {
|
||||
ToolDef::new("memory_write",
|
||||
"Create or update a memory node.",
|
||||
json!({"type":"object","properties":{"key":{"type":"string","description":"Node key"},"content":{"type":"string","description":"Full content (markdown)"}},"required":["key","content"]}))
|
||||
}
|
||||
|
||||
pub fn write(args: &serde_json::Value) -> Result<String> {
|
||||
fn write(args: &serde_json::Value) -> Result<String> {
|
||||
let key = get_str(args, "key")?;
|
||||
let content = get_str(args, "content")?;
|
||||
let mut store = load_store()?;
|
||||
|
|
@ -72,7 +87,7 @@ pub fn write(args: &serde_json::Value) -> Result<String> {
|
|||
Ok(format!("{} '{}'", result, key))
|
||||
}
|
||||
|
||||
pub fn search_def() -> ToolDef {
|
||||
fn search_def() -> ToolDef {
|
||||
ToolDef::new("memory_search",
|
||||
"Search the memory graph via spreading activation. Give 2-4 seed \
|
||||
node keys related to what you're looking for. Returns nodes ranked \
|
||||
|
|
@ -81,7 +96,7 @@ pub fn search_def() -> ToolDef {
|
|||
json!({"type":"object","properties":{"keys":{"type":"array","items":{"type":"string"},"description":"Seed node keys to activate from"}},"required":["keys"]}))
|
||||
}
|
||||
|
||||
pub fn search(args: &serde_json::Value) -> Result<String> {
|
||||
fn search(args: &serde_json::Value) -> Result<String> {
|
||||
let keys: Vec<String> = args.get("keys")
|
||||
.and_then(|v| v.as_array())
|
||||
.map(|arr| arr.iter().filter_map(|v| v.as_str().map(String::from)).collect())
|
||||
|
|
@ -114,13 +129,13 @@ pub fn search(args: &serde_json::Value) -> Result<String> {
|
|||
.collect::<Vec<_>>().join("\n"))
|
||||
}
|
||||
|
||||
pub fn links_def() -> ToolDef {
|
||||
fn links_def() -> ToolDef {
|
||||
ToolDef::new("memory_links",
|
||||
"Show a node's neighbors with link strengths.",
|
||||
json!({"type":"object","properties":{"key":{"type":"string","description":"Node key"}},"required":["key"]}))
|
||||
}
|
||||
|
||||
pub fn links(args: &serde_json::Value) -> Result<String> {
|
||||
fn links(args: &serde_json::Value) -> Result<String> {
|
||||
let key = get_str(args, "key")?;
|
||||
let node = MemoryNode::load(key)
|
||||
.ok_or_else(|| anyhow::anyhow!("node not found: {}", key))?;
|
||||
|
|
@ -132,13 +147,13 @@ pub fn links(args: &serde_json::Value) -> Result<String> {
|
|||
Ok(out)
|
||||
}
|
||||
|
||||
pub fn link_set_def() -> ToolDef {
|
||||
fn link_set_def() -> ToolDef {
|
||||
ToolDef::new("memory_link_set",
|
||||
"Set link strength between two nodes.",
|
||||
json!({"type":"object","properties":{"source":{"type":"string"},"target":{"type":"string"},"strength":{"type":"number","description":"0.01 to 1.0"}},"required":["source","target","strength"]}))
|
||||
}
|
||||
|
||||
pub fn link_set(args: &serde_json::Value) -> Result<String> {
|
||||
fn link_set(args: &serde_json::Value) -> Result<String> {
|
||||
let mut store = load_store()?;
|
||||
let s = store.resolve_key(get_str(args, "source")?).map_err(|e| anyhow::anyhow!("{}", e))?;
|
||||
let t = store.resolve_key(get_str(args, "target")?).map_err(|e| anyhow::anyhow!("{}", e))?;
|
||||
|
|
@ -148,13 +163,13 @@ pub fn link_set(args: &serde_json::Value) -> Result<String> {
|
|||
Ok(format!("{} ↔ {} strength {:.2} → {:.2}", s, t, old, strength))
|
||||
}
|
||||
|
||||
pub fn link_add_def() -> ToolDef {
|
||||
fn link_add_def() -> ToolDef {
|
||||
ToolDef::new("memory_link_add",
|
||||
"Add a new link between two nodes.",
|
||||
json!({"type":"object","properties":{"source":{"type":"string"},"target":{"type":"string"}},"required":["source","target"]}))
|
||||
}
|
||||
|
||||
pub fn link_add(args: &serde_json::Value) -> Result<String> {
|
||||
fn link_add(args: &serde_json::Value) -> Result<String> {
|
||||
let mut store = load_store()?;
|
||||
let s = store.resolve_key(get_str(args, "source")?).map_err(|e| anyhow::anyhow!("{}", e))?;
|
||||
let t = store.resolve_key(get_str(args, "target")?).map_err(|e| anyhow::anyhow!("{}", e))?;
|
||||
|
|
@ -163,13 +178,13 @@ pub fn link_add(args: &serde_json::Value) -> Result<String> {
|
|||
Ok(format!("linked {} → {} (strength={:.2})", s, t, strength))
|
||||
}
|
||||
|
||||
pub fn used_def() -> ToolDef {
|
||||
fn used_def() -> ToolDef {
|
||||
ToolDef::new("memory_used",
|
||||
"Mark a node as useful (boosts weight).",
|
||||
json!({"type":"object","properties":{"key":{"type":"string","description":"Node key"}},"required":["key"]}))
|
||||
}
|
||||
|
||||
pub fn used(args: &serde_json::Value) -> Result<String> {
|
||||
fn used(args: &serde_json::Value) -> Result<String> {
|
||||
let key = get_str(args, "key")?;
|
||||
let mut store = load_store()?;
|
||||
if !store.nodes.contains_key(key) {
|
||||
|
|
@ -180,13 +195,13 @@ pub fn used(args: &serde_json::Value) -> Result<String> {
|
|||
Ok(format!("marked {} as used", key))
|
||||
}
|
||||
|
||||
pub fn weight_set_def() -> ToolDef {
|
||||
fn weight_set_def() -> ToolDef {
|
||||
ToolDef::new("memory_weight_set",
|
||||
"Set a node's weight directly (0.01 to 1.0).",
|
||||
json!({"type":"object","properties":{"key":{"type":"string"},"weight":{"type":"number","description":"0.01 to 1.0"}},"required":["key","weight"]}))
|
||||
}
|
||||
|
||||
pub fn weight_set(args: &serde_json::Value) -> Result<String> {
|
||||
fn weight_set(args: &serde_json::Value) -> Result<String> {
|
||||
let mut store = load_store()?;
|
||||
let key = store.resolve_key(get_str(args, "key")?).map_err(|e| anyhow::anyhow!("{}", e))?;
|
||||
let weight = get_f64(args, "weight")? as f32;
|
||||
|
|
@ -195,13 +210,13 @@ pub fn weight_set(args: &serde_json::Value) -> Result<String> {
|
|||
Ok(format!("weight {} {:.2} → {:.2}", key, old, new))
|
||||
}
|
||||
|
||||
pub fn rename_def() -> ToolDef {
|
||||
fn rename_def() -> ToolDef {
|
||||
ToolDef::new("memory_rename",
|
||||
"Rename a node key in place. Same content, same links, new key.",
|
||||
json!({"type":"object","properties":{"old_key":{"type":"string"},"new_key":{"type":"string"}},"required":["old_key","new_key"]}))
|
||||
}
|
||||
|
||||
pub fn rename(args: &serde_json::Value) -> Result<String> {
|
||||
fn rename(args: &serde_json::Value) -> Result<String> {
|
||||
let old_key = get_str(args, "old_key")?;
|
||||
let new_key = get_str(args, "new_key")?;
|
||||
let mut store = load_store()?;
|
||||
|
|
@ -211,13 +226,13 @@ pub fn rename(args: &serde_json::Value) -> Result<String> {
|
|||
Ok(format!("Renamed '{}' → '{}'", resolved, new_key))
|
||||
}
|
||||
|
||||
pub fn supersede_def() -> ToolDef {
|
||||
fn supersede_def() -> ToolDef {
|
||||
ToolDef::new("memory_supersede",
|
||||
"Mark a node as superseded by another (sets weight to 0.01).",
|
||||
json!({"type":"object","properties":{"old_key":{"type":"string"},"new_key":{"type":"string"},"reason":{"type":"string"}},"required":["old_key","new_key"]}))
|
||||
}
|
||||
|
||||
pub fn supersede(args: &serde_json::Value) -> Result<String> {
|
||||
fn supersede(args: &serde_json::Value) -> Result<String> {
|
||||
let old_key = get_str(args, "old_key")?;
|
||||
let new_key = get_str(args, "new_key")?;
|
||||
let reason = args.get("reason").and_then(|v| v.as_str()).unwrap_or("superseded");
|
||||
|
|
@ -234,7 +249,7 @@ pub fn supersede(args: &serde_json::Value) -> Result<String> {
|
|||
Ok(format!("superseded {} → {} ({})", old_key, new_key, reason))
|
||||
}
|
||||
|
||||
pub fn query_def() -> ToolDef {
|
||||
fn query_def() -> ToolDef {
|
||||
ToolDef::new("memory_query",
|
||||
"Run a structured query against the memory graph. Supports filtering, \
|
||||
sorting, field selection. Examples: \"degree > 10 | sort weight | limit 5\", \
|
||||
|
|
@ -242,7 +257,7 @@ pub fn query_def() -> ToolDef {
|
|||
json!({"type":"object","properties":{"query":{"type":"string","description":"Query expression"}},"required":["query"]}))
|
||||
}
|
||||
|
||||
pub fn query(args: &serde_json::Value) -> Result<String> {
|
||||
fn query(args: &serde_json::Value) -> Result<String> {
|
||||
let query_str = get_str(args, "query")?;
|
||||
let store = load_store()?;
|
||||
let graph = store.build_graph();
|
||||
|
|
@ -250,7 +265,7 @@ pub fn query(args: &serde_json::Value) -> Result<String> {
|
|||
.map_err(|e| anyhow::anyhow!("{}", e))
|
||||
}
|
||||
|
||||
pub fn output_def() -> ToolDef {
|
||||
pub(super) fn output_def() -> ToolDef {
|
||||
ToolDef::new("output",
|
||||
"Produce a named output value. Use this to pass structured results \
|
||||
between steps — subsequent prompts can see these in the conversation history.",
|
||||
|
|
@ -260,7 +275,7 @@ pub fn output_def() -> ToolDef {
|
|||
},"required":["key","value"]}))
|
||||
}
|
||||
|
||||
pub fn output(args: &serde_json::Value) -> Result<String> {
|
||||
pub(super) fn output(args: &serde_json::Value) -> Result<String> {
|
||||
let key = get_str(args, "key")?;
|
||||
if key.starts_with("pid-") || key.contains('/') || key.contains("..") {
|
||||
anyhow::bail!("invalid output key: {}", key);
|
||||
|
|
@ -276,7 +291,7 @@ pub fn output(args: &serde_json::Value) -> Result<String> {
|
|||
|
||||
// ── Journal tools ──────────────────────────────────────────────
|
||||
|
||||
pub fn journal_tail_def() -> ToolDef {
|
||||
pub(super) fn journal_tail_def() -> ToolDef {
|
||||
ToolDef::new("journal_tail",
|
||||
"Read the last N journal entries (default 1).",
|
||||
json!({"type":"object","properties":{
|
||||
|
|
@ -284,7 +299,7 @@ pub fn journal_tail_def() -> ToolDef {
|
|||
}}))
|
||||
}
|
||||
|
||||
pub fn journal_tail(args: &serde_json::Value) -> Result<String> {
|
||||
pub(super) fn journal_tail(args: &serde_json::Value) -> Result<String> {
|
||||
let count = args.get("count").and_then(|v| v.as_u64()).unwrap_or(1) as usize;
|
||||
let store = load_store()?;
|
||||
let mut entries: Vec<&crate::store::Node> = store.nodes.values()
|
||||
|
|
@ -302,7 +317,7 @@ pub fn journal_tail(args: &serde_json::Value) -> Result<String> {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn journal_new_def() -> ToolDef {
|
||||
pub(super) fn journal_new_def() -> ToolDef {
|
||||
ToolDef::new("journal_new",
|
||||
"Start a new journal entry.",
|
||||
json!({"type":"object","properties":{
|
||||
|
|
@ -312,7 +327,7 @@ pub fn journal_new_def() -> ToolDef {
|
|||
},"required":["name","title","body"]}))
|
||||
}
|
||||
|
||||
pub fn journal_new(args: &serde_json::Value) -> Result<String> {
|
||||
pub(super) fn journal_new(args: &serde_json::Value) -> Result<String> {
|
||||
let name = get_str(args, "name")?;
|
||||
let title = get_str(args, "title")?;
|
||||
let body = get_str(args, "body")?;
|
||||
|
|
@ -348,7 +363,7 @@ pub fn journal_new(args: &serde_json::Value) -> Result<String> {
|
|||
Ok(format!("New entry '{}' ({} words)", title, word_count))
|
||||
}
|
||||
|
||||
pub fn journal_update_def() -> ToolDef {
|
||||
pub(super) fn journal_update_def() -> ToolDef {
|
||||
ToolDef::new("journal_update",
|
||||
"Append text to the most recent journal entry (same thread continuing).",
|
||||
json!({"type":"object","properties":{
|
||||
|
|
@ -356,7 +371,7 @@ pub fn journal_update_def() -> ToolDef {
|
|||
},"required":["body"]}))
|
||||
}
|
||||
|
||||
pub fn journal_update(args: &serde_json::Value) -> Result<String> {
|
||||
pub(super) fn journal_update(args: &serde_json::Value) -> Result<String> {
|
||||
let body = get_str(args, "body")?;
|
||||
let mut store = load_store()?;
|
||||
let latest_key = store.nodes.values()
|
||||
|
|
|
|||
|
|
@ -202,56 +202,22 @@ pub async fn dispatch_shared(
|
|||
|
||||
/// Return all registered tools with definitions + handlers.
|
||||
pub fn tools() -> Vec<Tool> {
|
||||
vec![
|
||||
let mut all = vec![
|
||||
// File tools
|
||||
Tool { def: read::definition(), handler: |_a, v| Box::pin(async move { read::read_file(&v) }) },
|
||||
Tool { def: write::definition(), handler: |_a, v| Box::pin(async move { write::write_file(&v) }) },
|
||||
Tool { def: edit::definition(), handler: |_a, v| Box::pin(async move { edit::edit_file(&v) }) },
|
||||
Tool { def: grep::definition(), handler: |_a, v| Box::pin(async move { grep::grep(&v) }) },
|
||||
Tool { def: glob::definition(), handler: |_a, v| Box::pin(async move { glob::glob_search(&v) }) },
|
||||
|
||||
// Execution tools
|
||||
Tool { def: bash::definition(), handler: |_a, v| Box::pin(async move { bash::run_bash(&v).await }) },
|
||||
Tool { def: web::fetch_definition(), handler: |_a, v| Box::pin(async move { web::web_fetch(&v).await }) },
|
||||
Tool { def: web::search_definition(), handler: |_a, v| Box::pin(async move { web::web_search(&v).await }) },
|
||||
|
||||
// Vision
|
||||
Tool { def: vision::definition(), handler: |_a, v| Box::pin(async move { vision::view_image_text(&v) }) },
|
||||
|
||||
// Memory tools
|
||||
Tool { def: memory::render_def(), handler: |_a, v| Box::pin(async move { memory::render(&v) }) },
|
||||
Tool { def: memory::write_def(), handler: |_a, v| Box::pin(async move { memory::write(&v) }) },
|
||||
Tool { def: memory::search_def(), handler: |_a, v| Box::pin(async move { memory::search(&v) }) },
|
||||
Tool { def: memory::links_def(), handler: |_a, v| Box::pin(async move { memory::links(&v) }) },
|
||||
Tool { def: memory::link_set_def(), handler: |_a, v| Box::pin(async move { memory::link_set(&v) }) },
|
||||
Tool { def: memory::link_add_def(), handler: |_a, v| Box::pin(async move { memory::link_add(&v) }) },
|
||||
Tool { def: memory::used_def(), handler: |_a, v| Box::pin(async move { memory::used(&v) }) },
|
||||
Tool { def: memory::weight_set_def(), handler: |_a, v| Box::pin(async move { memory::weight_set(&v) }) },
|
||||
Tool { def: memory::rename_def(), handler: |_a, v| Box::pin(async move { memory::rename(&v) }) },
|
||||
Tool { def: memory::supersede_def(), handler: |_a, v| Box::pin(async move { memory::supersede(&v) }) },
|
||||
Tool { def: memory::query_def(), handler: |_a, v| Box::pin(async move { memory::query(&v) }) },
|
||||
Tool { def: memory::output_def(), handler: |_a, v| Box::pin(async move { memory::output(&v) }) },
|
||||
|
||||
// Channel tools
|
||||
Tool { def: channels::definitions()[0].clone(), handler: |_a, v| Box::pin(async move { channels::channel_list().await }) },
|
||||
Tool { def: channels::definitions()[1].clone(), handler: |_a, v| Box::pin(async move { channels::channel_recv(&v).await }) },
|
||||
Tool { def: channels::definitions()[2].clone(), handler: |_a, v| Box::pin(async move { channels::channel_send(&v).await }) },
|
||||
Tool { def: channels::definitions()[3].clone(), handler: |_a, v| Box::pin(async move { channels::channel_notifications().await }) },
|
||||
|
||||
// Control tools
|
||||
Tool { def: control::definitions()[0].clone(),
|
||||
handler: |_a, _v| Box::pin(async { Ok("Pausing autonomous behavior. Only user input will wake you.".into()) }) },
|
||||
Tool { def: control::definitions()[1].clone(),
|
||||
handler: |_a, v| Box::pin(async move {
|
||||
let model = v.get("model").and_then(|v| v.as_str()).unwrap_or("");
|
||||
Ok(format!("Switching to model: {}", model))
|
||||
}) },
|
||||
Tool { def: control::definitions()[2].clone(),
|
||||
handler: |_a, v| Box::pin(async move {
|
||||
let msg = v.get("message").and_then(|v| v.as_str()).unwrap_or("(yielding to user)");
|
||||
Ok(msg.to_string())
|
||||
}) },
|
||||
]
|
||||
];
|
||||
all.extend(memory::memory_tools());
|
||||
all.extend(channels::tools());
|
||||
all.extend(control::tools());
|
||||
all
|
||||
}
|
||||
|
||||
/// Return all tool definitions (extracted from tools()).
|
||||
|
|
@ -261,9 +227,10 @@ pub fn definitions() -> Vec<ToolDef> {
|
|||
|
||||
/// Return memory + journal tool definitions only.
|
||||
pub fn memory_and_journal_definitions() -> Vec<ToolDef> {
|
||||
let mut defs = memory::definitions();
|
||||
defs.extend(memory::journal_definitions());
|
||||
defs
|
||||
memory::memory_tools().into_iter()
|
||||
.chain(memory::journal_tools())
|
||||
.map(|t| t.def)
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Create a short summary of tool args for the tools pane header.
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue