- take the 2.8.0 crate versions, Cargo.lock dependency graph and release workflows - keep the native workflow inspect/list, resume_dir isolation and repeatable fixtures - satisfy the 2.8.0 library narrative gate for workflow.tick - resolve CHANGELOG ordering with the v2.8.0 release entry
1114 lines
36 KiB
Rust
Executable File
1114 lines
36 KiB
Rust
Executable File
//! Agent plugin (C ABI v2): layout helpers + session bag + context via host_query + agent-kb + v2 memory + adaptive route.
|
|
|
|
mod choice;
|
|
mod context_pack;
|
|
mod context_scope;
|
|
mod corpus;
|
|
mod effects;
|
|
mod eng;
|
|
mod error;
|
|
mod input;
|
|
mod kb;
|
|
mod mcp_client;
|
|
mod mcp_server;
|
|
mod memory;
|
|
mod output;
|
|
mod parallel;
|
|
mod resume;
|
|
mod route;
|
|
mod sandbox;
|
|
mod tools;
|
|
mod workflow;
|
|
|
|
use std::collections::HashMap;
|
|
use std::ffi::CString;
|
|
use std::os::raw::{c_char, c_int};
|
|
use std::path::{Component, Path, PathBuf};
|
|
use std::ptr;
|
|
use std::sync::{LazyLock, Mutex};
|
|
|
|
use marqdo_plugin_sdk::*;
|
|
|
|
const DEFAULT_MARKERS: &str = "agents,runbooks,marqdo.agent.json";
|
|
const LAYOUT_DIRS: &[&str] = &["agents", "runbooks", "templates", "reports"];
|
|
|
|
|
|
static HISTORIES: LazyLock<Mutex<HashMap<String, Vec<serde_json::Value>>>> =
|
|
LazyLock::new(|| Mutex::new(HashMap::new()));
|
|
static AGENT_SEQ: LazyLock<Mutex<u64>> = LazyLock::new(|| Mutex::new(0));
|
|
|
|
unsafe fn arg_str<'a>(v: &'a serde_json::Value, key: &str) -> Result<&'a str, String> {
|
|
v.get(key)
|
|
.and_then(|x| x.as_str())
|
|
.ok_or_else(|| format!("missing text `{key}`"))
|
|
}
|
|
|
|
fn has_parent_escape(rel: &Path) -> bool {
|
|
rel.components().any(|c| matches!(c, Component::ParentDir))
|
|
}
|
|
|
|
fn find_root(start: &str, markers: &str) -> Result<PathBuf, String> {
|
|
let markers: Vec<&str> = markers
|
|
.split(',')
|
|
.map(|s| s.trim())
|
|
.filter(|s| !s.is_empty())
|
|
.collect();
|
|
if markers.is_empty() {
|
|
return Err("empty markers".into());
|
|
}
|
|
let mut cur = PathBuf::from(start);
|
|
if cur.as_os_str().is_empty() {
|
|
cur = std::env::current_dir().map_err(|e| e.to_string())?;
|
|
}
|
|
if !cur.exists() {
|
|
return Err(format!("start path missing: {}", cur.display()));
|
|
}
|
|
let mut cur = std::fs::canonicalize(&cur).map_err(|e| e.to_string())?;
|
|
loop {
|
|
for m in &markers {
|
|
let p = cur.join(m);
|
|
let ok = if m.contains('.') {
|
|
p.is_file()
|
|
} else {
|
|
p.is_dir()
|
|
};
|
|
if ok {
|
|
return Ok(cur);
|
|
}
|
|
}
|
|
if !cur.pop() {
|
|
break;
|
|
}
|
|
}
|
|
Err("agent project root not found".into())
|
|
}
|
|
|
|
fn ensure_layout(root: &Path) -> Result<i64, String> {
|
|
let root = std::fs::canonicalize(root).map_err(|e| e.to_string())?;
|
|
let mut created = 0i64;
|
|
for d in LAYOUT_DIRS {
|
|
let p = root.join(d);
|
|
if !p.exists() {
|
|
std::fs::create_dir_all(&p).map_err(|e| e.to_string())?;
|
|
created += 1;
|
|
} else if !p.is_dir() {
|
|
return Err(format!("{} exists and is not a directory", p.display()));
|
|
}
|
|
}
|
|
Ok(created)
|
|
}
|
|
|
|
fn probe(root: &Path) -> Result<serde_json::Value, String> {
|
|
let root = std::fs::canonicalize(root).map_err(|e| e.to_string())?;
|
|
let mut map = serde_json::Map::new();
|
|
map.insert(
|
|
"root".into(),
|
|
serde_json::Value::String(root.to_string_lossy().into_owned()),
|
|
);
|
|
for d in LAYOUT_DIRS {
|
|
let key = format!("has_{d}");
|
|
map.insert(key, serde_json::Value::Bool(root.join(d).is_dir()));
|
|
}
|
|
Ok(serde_json::Value::Object(map))
|
|
}
|
|
|
|
fn scaffold(root: &Path, name: &str, template: &str, dest: &str) -> Result<String, String> {
|
|
if name.is_empty() {
|
|
return Err("name is empty".into());
|
|
}
|
|
let root = std::fs::canonicalize(root).map_err(|e| e.to_string())?;
|
|
let tmpl_rel = Path::new(template);
|
|
let dest_rel = Path::new(dest);
|
|
if has_parent_escape(tmpl_rel) {
|
|
return Err("template path escapes project root".into());
|
|
}
|
|
if has_parent_escape(dest_rel) {
|
|
return Err("dest path escapes project root".into());
|
|
}
|
|
let tmpl_path = root.join(tmpl_rel);
|
|
if !tmpl_path.is_file() {
|
|
return Err(format!("template not found: {}", tmpl_path.display()));
|
|
}
|
|
let tmpl_can = std::fs::canonicalize(&tmpl_path).map_err(|e| e.to_string())?;
|
|
if !tmpl_can.starts_with(&root) {
|
|
return Err("template path escapes project root".into());
|
|
}
|
|
let dest_path = root.join(dest_rel);
|
|
if let Some(parent) = dest_path.parent() {
|
|
std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
|
|
let parent_can = std::fs::canonicalize(parent).map_err(|e| e.to_string())?;
|
|
if !parent_can.starts_with(&root) {
|
|
return Err("dest path escapes project root".into());
|
|
}
|
|
}
|
|
let body = std::fs::read_to_string(&tmpl_can).map_err(|e| e.to_string())?;
|
|
let body = body.replace("{{name}}", name);
|
|
std::fs::write(&dest_path, body).map_err(|e| e.to_string())?;
|
|
Ok(dest_path.to_string_lossy().into_owned())
|
|
}
|
|
|
|
fn map_get_str<'a>(m: &'a serde_json::Value, keys: &[&str]) -> Option<&'a str> {
|
|
let obj = m.as_object()?;
|
|
for k in keys {
|
|
if let Some(v) = obj.get(*k) {
|
|
if let Some(s) = v.as_str() {
|
|
return Some(s);
|
|
}
|
|
if let Some(n) = v.as_i64() {
|
|
// allow numeric fields to be read as display later
|
|
let _ = n;
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn map_get_i64(m: &serde_json::Value, keys: &[&str]) -> i64 {
|
|
let Some(obj) = m.as_object() else {
|
|
return i64::MAX;
|
|
};
|
|
for k in keys {
|
|
if let Some(v) = obj.get(*k) {
|
|
if let Some(n) = v.as_i64() {
|
|
return n;
|
|
}
|
|
if let Some(s) = v.as_str() {
|
|
if let Ok(n) = s.parse::<i64>() {
|
|
return n;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
i64::MAX
|
|
}
|
|
|
|
fn skills_text(m: &serde_json::Value) -> String {
|
|
map_get_str(m, &["技能", "skills", "skill"])
|
|
.unwrap_or("")
|
|
.to_string()
|
|
}
|
|
|
|
fn match_skill(skill: &str, members: &serde_json::Value) -> Result<serde_json::Value, String> {
|
|
let arr = members
|
|
.as_array()
|
|
.ok_or_else(|| "members must be a JSON array".to_string())?;
|
|
let skill = skill.trim();
|
|
if skill.is_empty() {
|
|
return Err("skill is empty".into());
|
|
}
|
|
let mut best: Option<&serde_json::Value> = None;
|
|
let mut best_load = i64::MAX;
|
|
for m in arr {
|
|
let sk = skills_text(m);
|
|
if sk.split(',').any(|p| p.trim() == skill) || sk.contains(skill) {
|
|
let load = map_get_i64(m, &["负载", "load"]);
|
|
if load < best_load {
|
|
best_load = load;
|
|
best = Some(m);
|
|
}
|
|
}
|
|
}
|
|
Ok(best.cloned().unwrap_or(serde_json::Value::Null))
|
|
}
|
|
|
|
fn bump_load(member: &serde_json::Value, delta: i64) -> Result<serde_json::Value, String> {
|
|
let mut obj = member
|
|
.as_object()
|
|
.cloned()
|
|
.ok_or_else(|| "member must be a JSON object".to_string())?;
|
|
let key = if obj.contains_key("负载") {
|
|
"负载"
|
|
} else if obj.contains_key("load") {
|
|
"load"
|
|
} else {
|
|
obj.insert("负载".into(), serde_json::Value::Number(0.into()));
|
|
"负载"
|
|
};
|
|
let cur = match obj.get(key) {
|
|
Some(serde_json::Value::Number(n)) => n.as_i64().unwrap_or(0),
|
|
Some(serde_json::Value::String(s)) => s.parse().unwrap_or(0),
|
|
_ => 0,
|
|
};
|
|
obj.insert(
|
|
key.into(),
|
|
serde_json::Value::Number((cur + delta).into()),
|
|
);
|
|
Ok(serde_json::Value::Object(obj))
|
|
}
|
|
|
|
unsafe extern "C" fn agent_find_root(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_find_root: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let start = match arg_str(&v, "start") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_find_root: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let markers = v
|
|
.get("markers")
|
|
.and_then(|x| x.as_str())
|
|
.filter(|s| !s.is_empty())
|
|
.unwrap_or(DEFAULT_MARKERS);
|
|
match find_root(start, markers) {
|
|
Ok(p) => {
|
|
let out = serde_json::Value::String(p.to_string_lossy().into_owned()).to_string();
|
|
set_out(out_json, &out);
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_find_root: {e}"));
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
unsafe extern "C" fn agent_ensure_layout(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_ensure_layout: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let root = match arg_str(&v, "root") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_ensure_layout: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
match ensure_layout(Path::new(root)) {
|
|
Ok(n) => {
|
|
set_out(out_json, &n.to_string());
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_ensure_layout: {e}"));
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
unsafe extern "C" fn agent_probe(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_probe: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let root = match arg_str(&v, "root") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_probe: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
match probe(Path::new(root)) {
|
|
Ok(j) => {
|
|
set_out(out_json, &j.to_string());
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_probe: {e}"));
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
unsafe extern "C" fn agent_scaffold(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_scaffold: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let root = match arg_str(&v, "root") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_scaffold: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let name = match arg_str(&v, "name") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_scaffold: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let template = match arg_str(&v, "template") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_scaffold: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let dest = match arg_str(&v, "dest") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_scaffold: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
match scaffold(Path::new(root), name, template, dest) {
|
|
Ok(p) => {
|
|
let out = serde_json::Value::String(p).to_string();
|
|
set_out(out_json, &out);
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_scaffold: {e}"));
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
unsafe extern "C" fn agent_match_skill(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_match_skill: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let skill = match arg_str(&v, "skill") {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_match_skill: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let members = match v.get("members") {
|
|
Some(m) => m.clone(),
|
|
None => {
|
|
set_err(err_msg, "agent_match_skill: missing members");
|
|
return 1;
|
|
}
|
|
};
|
|
// members may be a JSON string (from Marqdo stringify) or already an array
|
|
let members = if let Some(s) = members.as_str() {
|
|
match serde_json::from_str::<serde_json::Value>(s) {
|
|
Ok(j) => j,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_match_skill: members JSON: {e}"));
|
|
return 1;
|
|
}
|
|
}
|
|
} else {
|
|
members
|
|
};
|
|
match match_skill(skill, &members) {
|
|
Ok(j) => {
|
|
set_out(out_json, &j.to_string());
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_match_skill: {e}"));
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
unsafe extern "C" fn agent_bump_load(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_bump_load: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let member = match v.get("member") {
|
|
Some(m) => m.clone(),
|
|
None => {
|
|
set_err(err_msg, "agent_bump_load: missing member");
|
|
return 1;
|
|
}
|
|
};
|
|
let member = if let Some(s) = member.as_str() {
|
|
match serde_json::from_str::<serde_json::Value>(s) {
|
|
Ok(j) => j,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_bump_load: member JSON: {e}"));
|
|
return 1;
|
|
}
|
|
}
|
|
} else {
|
|
member
|
|
};
|
|
let delta = v.get("delta").and_then(|x| x.as_i64()).unwrap_or(1);
|
|
match bump_load(&member, delta) {
|
|
Ok(j) => {
|
|
set_out(out_json, &j.to_string());
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_bump_load: {e}"));
|
|
1
|
|
}
|
|
}
|
|
}
|
|
pub(crate) fn host_query_json_args(
|
|
name: &str,
|
|
args: &serde_json::Value,
|
|
) -> Result<serde_json::Value, String> {
|
|
let query = unsafe { HOST_QUERY }.ok_or_else(|| "host_query not available".to_string())?;
|
|
let userdata = unsafe { HOST_USERDATA };
|
|
let c_name = CString::new(name).map_err(|e| e.to_string())?;
|
|
let args_s = serde_json::to_string(args).map_err(|e| e.to_string())?;
|
|
let c_args = CString::new(args_s).map_err(|e| e.to_string())?;
|
|
let mut out_ptr: *mut c_char = ptr::null_mut();
|
|
let mut err_ptr: *mut c_char = ptr::null_mut();
|
|
let rc = unsafe {
|
|
query(
|
|
userdata,
|
|
c_name.as_ptr(),
|
|
c_args.as_ptr(),
|
|
&mut out_ptr,
|
|
&mut err_ptr,
|
|
)
|
|
};
|
|
let err = take_host_string(err_ptr);
|
|
let out = take_host_string(out_ptr);
|
|
if rc != 0 {
|
|
return Err(err.unwrap_or_else(|| format!("host_query `{name}` failed")));
|
|
}
|
|
let out = out.unwrap_or_else(|| "null".into());
|
|
serde_json::from_str(&out).map_err(|e| format!("host_query `{name}` bad JSON: {e}"))
|
|
}
|
|
|
|
unsafe extern "C" fn agent_alloc(
|
|
_args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let mut seq = match AGENT_SEQ.lock() {
|
|
Ok(g) => g,
|
|
Err(_) => {
|
|
set_err(err_msg, "agent_alloc: lock poisoned");
|
|
return 1;
|
|
}
|
|
};
|
|
*seq = seq.wrapping_add(1);
|
|
let id = format!("agent-{seq}");
|
|
drop(seq);
|
|
if let Ok(mut map) = HISTORIES.lock() {
|
|
map.insert(id.clone(), Vec::new());
|
|
}
|
|
let out = serde_json::Value::String(id).to_string();
|
|
set_out(out_json, &out);
|
|
0
|
|
}
|
|
|
|
unsafe extern "C" fn agent_history_get(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_history_get: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let id = match arg_str(&v, "id") {
|
|
Ok(s) => s.to_string(),
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_history_get: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let list = HISTORIES
|
|
.lock()
|
|
.map(|m| m.get(&id).cloned().unwrap_or_default())
|
|
.unwrap_or_default();
|
|
set_out(out_json, &serde_json::Value::Array(list).to_string());
|
|
0
|
|
}
|
|
|
|
unsafe extern "C" fn agent_history_clear(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_history_clear: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let id = match arg_str(&v, "id") {
|
|
Ok(s) => s.to_string(),
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_history_clear: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
if let Ok(mut map) = HISTORIES.lock() {
|
|
map.insert(id, Vec::new());
|
|
}
|
|
set_out(out_json, "null");
|
|
0
|
|
}
|
|
|
|
unsafe extern "C" fn agent_history_append(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_history_append: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let id = match arg_str(&v, "id") {
|
|
Ok(s) => s.to_string(),
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_history_append: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let item = match v.get("item") {
|
|
Some(i) => i.clone(),
|
|
None => {
|
|
set_err(err_msg, "agent_history_append: missing item");
|
|
return 1;
|
|
}
|
|
};
|
|
let list = match HISTORIES.lock() {
|
|
Ok(mut map) => {
|
|
let list = map.entry(id).or_default();
|
|
list.push(item);
|
|
list.clone()
|
|
}
|
|
Err(_) => {
|
|
set_err(err_msg, "agent_history_append: lock poisoned");
|
|
return 1;
|
|
}
|
|
};
|
|
set_out(out_json, &serde_json::Value::Array(list).to_string());
|
|
0
|
|
}
|
|
|
|
unsafe extern "C" fn agent_module_source(
|
|
_args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
match host_query_json("module_source") {
|
|
Ok(j) => {
|
|
set_out(out_json, &j.to_string());
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &e);
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
unsafe extern "C" fn agent_call_site(
|
|
_args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
match host_query_json("call_site") {
|
|
Ok(j) => {
|
|
set_out(out_json, &j.to_string());
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &e);
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
unsafe extern "C" fn agent_marqdo_skill(
|
|
_args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
match host_query_json("marqdo_skill") {
|
|
Ok(j) => {
|
|
set_out(out_json, &j.to_string());
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &e);
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(crate) fn tool_names(tools: &serde_json::Value) -> Vec<String> {
|
|
let mut out = Vec::new();
|
|
let rows = match tools {
|
|
serde_json::Value::Array(a) => a.as_slice(),
|
|
serde_json::Value::String(s) => {
|
|
if let Ok(serde_json::Value::Array(a)) = serde_json::from_str(s) {
|
|
return tool_names(&serde_json::Value::Array(a));
|
|
}
|
|
return out;
|
|
}
|
|
_ => return out,
|
|
};
|
|
for row in rows {
|
|
match row {
|
|
serde_json::Value::String(s) if !s.is_empty() => out.push(s.clone()),
|
|
serde_json::Value::Object(m) => {
|
|
for key in ["工具", "tools", "name"] {
|
|
if let Some(serde_json::Value::String(s)) = m.get(key) {
|
|
if !s.is_empty() {
|
|
out.push(s.clone());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
out
|
|
}
|
|
|
|
unsafe extern "C" fn agent_format_tools(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_format_tools: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let tools = match v.get("tools") {
|
|
Some(t) => t,
|
|
None => {
|
|
set_err(err_msg, "agent_format_tools: missing tools");
|
|
return 1;
|
|
}
|
|
};
|
|
let mut text =
|
|
String::from("Available tools (invoke via CALL:<name> or 调用:<name>; runs as subtask):\n");
|
|
for name in tool_names(tools) {
|
|
text.push_str("- ");
|
|
text.push_str(&name);
|
|
text.push('\n');
|
|
}
|
|
set_out(out_json, &serde_json::Value::String(text).to_string());
|
|
0
|
|
}
|
|
|
|
unsafe extern "C" fn agent_tool_allowed(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("agent_tool_allowed: {e}"));
|
|
return 1;
|
|
}
|
|
};
|
|
let tools = match v.get("tools") {
|
|
Some(t) => t,
|
|
None => {
|
|
set_err(err_msg, "agent_tool_allowed: missing tools");
|
|
return 1;
|
|
}
|
|
};
|
|
let name = match arg_str(&v, "name") {
|
|
Ok(s) => s,
|
|
Err(_) => {
|
|
set_out(out_json, "false");
|
|
return 0;
|
|
}
|
|
};
|
|
let ok = tool_names(tools).iter().any(|n| n == name);
|
|
set_out(out_json, if ok { "true" } else { "false" });
|
|
0
|
|
}
|
|
|
|
macro_rules! kb_ffi {
|
|
($fn_name:ident, $call:expr, $label:expr) => {
|
|
unsafe extern "C" fn $fn_name(
|
|
args_json: *const c_char,
|
|
out_json: *mut *mut c_char,
|
|
err_msg: *mut *mut c_char,
|
|
) -> c_int {
|
|
let v = match parse_args(args_json) {
|
|
Ok(v) => v,
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("{}: {e}", $label));
|
|
return 1;
|
|
}
|
|
};
|
|
match $call(&v) {
|
|
Ok(out) => {
|
|
set_out(out_json, &out.to_string());
|
|
0
|
|
}
|
|
Err(e) => {
|
|
set_err(err_msg, &format!("{}: {e}", $label));
|
|
1
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
kb_ffi!(agent_goal_sig, kb::goal_sig, "agent_goal_sig");
|
|
kb_ffi!(agent_goal_slug, kb::goal_slug, "agent_goal_slug");
|
|
kb_ffi!(agent_kb_canonicalize, kb::kb_canonicalize, "agent_kb_canonicalize");
|
|
kb_ffi!(agent_kb_lookup, kb::kb_lookup, "agent_kb_lookup");
|
|
kb_ffi!(agent_kb_near_match, kb::kb_near_match, "agent_kb_near_match");
|
|
kb_ffi!(agent_kb_list_tasks, kb::kb_list_tasks, "agent_kb_list_tasks");
|
|
kb_ffi!(agent_corpus_search, corpus::corpus_search, "agent_corpus_search");
|
|
kb_ffi!(agent_mcp_fixture, corpus::mcp_fixture, "agent_mcp_fixture");
|
|
kb_ffi!(agent_kb_add_alias, kb::kb_add_alias, "agent_kb_add_alias");
|
|
kb_ffi!(agent_kb_promote, kb::kb_promote, "agent_kb_promote");
|
|
kb_ffi!(agent_kb_quarantine, kb::kb_quarantine, "agent_kb_quarantine");
|
|
kb_ffi!(agent_kb_record_hit, kb::kb_record_hit, "agent_kb_record_hit");
|
|
kb_ffi!(
|
|
agent_workbook_solidify,
|
|
kb::workbook_solidify,
|
|
"agent_workbook_solidify"
|
|
);
|
|
kb_ffi!(agent_kb_task_files, kb::kb_task_files, "agent_kb_task_files");
|
|
kb_ffi!(agent_memory_ensure, memory::memory_ensure, "agent_memory_ensure");
|
|
kb_ffi!(agent_record_episode, memory::record_episode, "agent_record_episode");
|
|
kb_ffi!(agent_list_episodes, memory::list_episodes, "agent_list_episodes");
|
|
kb_ffi!(agent_get_episode, memory::get_episode, "agent_get_episode");
|
|
kb_ffi!(agent_cluster_episodes, memory::cluster_episodes, "agent_cluster_episodes");
|
|
kb_ffi!(agent_extract_pattern, memory::extract_pattern, "agent_extract_pattern");
|
|
kb_ffi!(agent_generalize, memory::generalize, "agent_generalize");
|
|
kb_ffi!(agent_synthesize_skill, memory::synthesize_skill, "agent_synthesize_skill");
|
|
kb_ffi!(agent_compile_skill, memory::compile_skill, "agent_compile_skill");
|
|
kb_ffi!(agent_maybe_learn, memory::maybe_learn, "agent_maybe_learn");
|
|
kb_ffi!(agent_metrics, memory::metrics, "agent_metrics");
|
|
kb_ffi!(agent_resolve, memory::resolve_task, "agent_resolve");
|
|
kb_ffi!(agent_route, route::route, "agent_route");
|
|
kb_ffi!(agent_route_apply, route::route_apply, "agent_route_apply");
|
|
kb_ffi!(agent_compile_policy, route::compile_policy, "agent_compile_policy");
|
|
kb_ffi!(
|
|
agent_maybe_compile_policy,
|
|
route::maybe_compile_policy,
|
|
"agent_maybe_compile_policy"
|
|
);
|
|
kb_ffi!(agent_resume_save, resume::resume_save, "agent_resume_save");
|
|
kb_ffi!(agent_resume_load, resume::resume_load, "agent_resume_load");
|
|
kb_ffi!(agent_resume_clear, resume::resume_clear, "agent_resume_clear");
|
|
kb_ffi!(agent_resume_list, resume::resume_list, "agent_resume_list");
|
|
kb_ffi!(agent_choice_parse, choice::parse_choice, "agent_choice_parse");
|
|
kb_ffi!(agent_context_scope, context_scope::project, "agent_context_scope");
|
|
kb_ffi!(agent_input_open, input::input_open, "agent_input_open");
|
|
kb_ffi!(agent_input_resume, input::input_resume, "agent_input_resume");
|
|
kb_ffi!(agent_parallel_report, parallel::report, "agent_parallel_report");
|
|
kb_ffi!(agent_workflow_open, workflow::open, "agent_workflow_open");
|
|
kb_ffi!(agent_workflow_next, workflow::next, "agent_workflow_next");
|
|
kb_ffi!(agent_workflow_inspect, workflow::inspect, "agent_workflow_inspect");
|
|
kb_ffi!(agent_workflow_list, workflow::list, "agent_workflow_list");
|
|
kb_ffi!(agent_workflow_commit, workflow::commit, "agent_workflow_commit");
|
|
kb_ffi!(agent_workflow_cancel, workflow::cancel, "agent_workflow_cancel");
|
|
kb_ffi!(agent_workflow_retry_plan, workflow::retry_plan, "agent_workflow_retry_plan");
|
|
kb_ffi!(agent_workflow_retry_commit, workflow::retry_commit, "agent_workflow_retry_commit");
|
|
kb_ffi!(agent_error_make, error::make_error, "agent_error_make");
|
|
kb_ffi!(agent_error_decide_retry, error::decide_retry, "agent_error_decide_retry");
|
|
kb_ffi!(agent_tools_register, tools::tools_register, "agent_tools_register");
|
|
kb_ffi!(agent_tools_clear, tools::tools_clear, "agent_tools_clear");
|
|
kb_ffi!(agent_tools_search, tools::tools_search, "agent_tools_search");
|
|
kb_ffi!(agent_tools_describe, tools::tools_describe, "agent_tools_describe");
|
|
kb_ffi!(agent_tools_prepare_call, tools::tools_prepare_call, "agent_tools_prepare_call");
|
|
kb_ffi!(agent_tools_wrap_result, tools::tools_wrap_result, "agent_tools_wrap_result");
|
|
kb_ffi!(
|
|
agent_tools_args_digest,
|
|
tools::tools_args_digest,
|
|
"agent_tools_args_digest"
|
|
);
|
|
kb_ffi!(
|
|
agent_tools_needs_ledger,
|
|
tools::tools_needs_ledger,
|
|
"agent_tools_needs_ledger"
|
|
);
|
|
kb_ffi!(
|
|
agent_tools_register_eng_defaults,
|
|
tools::tools_register_eng_defaults,
|
|
"agent_tools_register_eng_defaults"
|
|
);
|
|
kb_ffi!(
|
|
agent_tools_seed_allowlist,
|
|
tools::seed_from_allowlist_args,
|
|
"agent_tools_seed_allowlist"
|
|
);
|
|
kb_ffi!(agent_output_build, output::output_build, "agent_output_build");
|
|
kb_ffi!(
|
|
agent_output_apply_policy,
|
|
output::output_apply_policy,
|
|
"agent_output_apply_policy"
|
|
);
|
|
kb_ffi!(
|
|
agent_output_channel_event,
|
|
output::output_channel_event,
|
|
"agent_output_channel_event"
|
|
);
|
|
kb_ffi!(
|
|
agent_output_project_conclusion,
|
|
output::output_project_conclusion,
|
|
"agent_output_project_conclusion"
|
|
);
|
|
kb_ffi!(
|
|
agent_context_pack_build,
|
|
context_pack::context_pack_build,
|
|
"agent_context_pack_build"
|
|
);
|
|
kb_ffi!(
|
|
agent_context_pack_compact,
|
|
context_pack::context_pack_compact,
|
|
"agent_context_pack_compact"
|
|
);
|
|
kb_ffi!(
|
|
agent_effects_prepare,
|
|
effects::effects_prepare,
|
|
"agent_effects_prepare"
|
|
);
|
|
kb_ffi!(
|
|
agent_effects_transition,
|
|
effects::effects_transition,
|
|
"agent_effects_transition"
|
|
);
|
|
kb_ffi!(agent_effects_get, effects::effects_get, "agent_effects_get");
|
|
kb_ffi!(
|
|
agent_effects_list,
|
|
effects::effects_list,
|
|
"agent_effects_list"
|
|
);
|
|
kb_ffi!(
|
|
agent_effects_watermark,
|
|
effects::effects_watermark,
|
|
"agent_effects_watermark"
|
|
);
|
|
kb_ffi!(
|
|
agent_effects_reconcile,
|
|
effects::effects_reconcile,
|
|
"agent_effects_reconcile"
|
|
);
|
|
kb_ffi!(agent_eng_preflight, eng::eng_preflight, "agent_eng_preflight");
|
|
kb_ffi!(agent_eng_reuse, eng::eng_reuse, "agent_eng_reuse");
|
|
kb_ffi!(agent_eng_bind_execute, eng::eng_bind_execute, "agent_eng_bind_execute");
|
|
kb_ffi!(agent_eng_publish_gate, eng::eng_publish_gate, "agent_eng_publish_gate");
|
|
kb_ffi!(agent_eng_record, eng::eng_record, "agent_eng_record");
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn marqdo_plugin_abi_version() -> u32 {
|
|
ABI_VERSION
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn marqdo_plugin_init(host: *const MarqdoHostApi) -> c_int {
|
|
if host.is_null() {
|
|
return 1;
|
|
}
|
|
if (*host).host_query.is_none() {
|
|
return 1;
|
|
}
|
|
let regs: &[(&str, &str, PluginFn)] = &[
|
|
("agent_find_root", "start,markers", agent_find_root),
|
|
("agent_ensure_layout", "root", agent_ensure_layout),
|
|
("agent_probe", "root", agent_probe),
|
|
("agent_scaffold", "root,name,template,dest", agent_scaffold),
|
|
("agent_match_skill", "skill,members", agent_match_skill),
|
|
("agent_bump_load", "member,delta", agent_bump_load),
|
|
("agent_alloc", "", agent_alloc),
|
|
("agent_history_get", "id", agent_history_get),
|
|
("agent_history_clear", "id", agent_history_clear),
|
|
("agent_history_append", "id,item", agent_history_append),
|
|
("agent_module_source", "", agent_module_source),
|
|
("agent_call_site", "", agent_call_site),
|
|
("agent_marqdo_skill", "", agent_marqdo_skill),
|
|
("agent_format_tools", "tools", agent_format_tools),
|
|
("agent_tool_allowed", "tools,name", agent_tool_allowed),
|
|
("agent_goal_sig", "goal", agent_goal_sig),
|
|
("agent_goal_slug", "goal", agent_goal_slug),
|
|
("agent_kb_canonicalize", "goal", agent_kb_canonicalize),
|
|
("agent_kb_lookup", "kb_dir,goal", agent_kb_lookup),
|
|
("agent_kb_near_match", "kb_dir,goal", agent_kb_near_match),
|
|
("agent_kb_list_tasks", "kb_dir", agent_kb_list_tasks),
|
|
("agent_corpus_search", "query", agent_corpus_search),
|
|
("agent_mcp_fixture", "action,fixture", agent_mcp_fixture),
|
|
("agent_mcp_serve", "name,tools,transport", mcp_server::agent_mcp_serve),
|
|
("agent_mcp_client", "action,command", mcp_client::agent_mcp_client),
|
|
("agent_resume_save", "id,goal,status,round", agent_resume_save),
|
|
("agent_resume_load", "id,resume_dir", agent_resume_load),
|
|
("agent_resume_clear", "id,resume_dir", agent_resume_clear),
|
|
("agent_resume_list", "resume_dir", agent_resume_list),
|
|
("agent_choice_parse", "reply,options", agent_choice_parse),
|
|
("agent_context_scope", "source,scope,class,function", agent_context_scope),
|
|
("agent_input_open", "id,question,options,source_revision", agent_input_open),
|
|
("agent_input_resume", "id,reply,source_revision", agent_input_resume),
|
|
("agent_parallel_report", "results", agent_parallel_report),
|
|
("agent_workflow_open", "id,steps,source_revision,session_id,principal_ref,resume_dir", agent_workflow_open),
|
|
("agent_workflow_next", "id,source_revision,session_id,principal_ref,resume_dir", agent_workflow_next),
|
|
("agent_workflow_inspect", "id,source_revision,session_id,principal_ref,resume_dir", agent_workflow_inspect),
|
|
("agent_workflow_list", "session_id,principal_ref,resume_dir", agent_workflow_list),
|
|
("agent_workflow_commit", "id,step_id,response,source_revision,session_id,principal_ref,resume_dir", agent_workflow_commit),
|
|
("agent_workflow_cancel", "id,source_revision,session_id,principal_ref,resume_dir", agent_workflow_cancel),
|
|
("agent_workflow_retry_plan", "id,source_revision,session_id,principal_ref,resume_dir", agent_workflow_retry_plan),
|
|
("agent_workflow_retry_commit", "id,results,source_revision,session_id,principal_ref,resume_dir", agent_workflow_retry_commit),
|
|
("agent_error_make", "code,message,category", agent_error_make),
|
|
("agent_error_decide_retry", "error,attempts,effect_class", agent_error_decide_retry),
|
|
("agent_tools_register", "spec,specs", agent_tools_register),
|
|
("agent_tools_clear", "", agent_tools_clear),
|
|
("agent_tools_search", "query,tools", agent_tools_search),
|
|
("agent_tools_describe", "id,tools", agent_tools_describe),
|
|
("agent_tools_prepare_call", "tool_id,arguments,tools", agent_tools_prepare_call),
|
|
("agent_tools_wrap_result", "ok,status,summary", agent_tools_wrap_result),
|
|
("agent_tools_args_digest", "arguments", agent_tools_args_digest),
|
|
("agent_tools_needs_ledger", "effect", agent_tools_needs_ledger),
|
|
(
|
|
"agent_tools_register_eng_defaults",
|
|
"",
|
|
agent_tools_register_eng_defaults,
|
|
),
|
|
("agent_tools_seed_allowlist", "tools", agent_tools_seed_allowlist),
|
|
("agent_output_build", "status,text,validation", agent_output_build),
|
|
(
|
|
"agent_output_apply_policy",
|
|
"status,text,policy",
|
|
agent_output_apply_policy,
|
|
),
|
|
(
|
|
"agent_output_channel_event",
|
|
"channel,delta",
|
|
agent_output_channel_event,
|
|
),
|
|
(
|
|
"agent_output_project_conclusion",
|
|
"document",
|
|
agent_output_project_conclusion,
|
|
),
|
|
(
|
|
"agent_context_pack_build",
|
|
"items,budget_tokens",
|
|
agent_context_pack_build,
|
|
),
|
|
(
|
|
"agent_context_pack_compact",
|
|
"items,budget_tokens",
|
|
agent_context_pack_compact,
|
|
),
|
|
(
|
|
"agent_effects_prepare",
|
|
"operation_id,idempotency_key,args_digest",
|
|
agent_effects_prepare,
|
|
),
|
|
(
|
|
"agent_effects_transition",
|
|
"operation_id,state",
|
|
agent_effects_transition,
|
|
),
|
|
("agent_effects_get", "operation_id", agent_effects_get),
|
|
("agent_effects_list", "ledger_dir", agent_effects_list),
|
|
(
|
|
"agent_effects_watermark",
|
|
"ledger_dir",
|
|
agent_effects_watermark,
|
|
),
|
|
(
|
|
"agent_effects_reconcile",
|
|
"operation_id,outcome",
|
|
agent_effects_reconcile,
|
|
),
|
|
("agent_kb_add_alias", "kb_dir,slug,alias", agent_kb_add_alias),
|
|
("agent_kb_promote", "kb_dir,goal,workbook", agent_kb_promote),
|
|
("agent_kb_quarantine", "kb_dir,slug", agent_kb_quarantine),
|
|
("agent_kb_record_hit", "kb_dir,goal", agent_kb_record_hit),
|
|
("agent_workbook_solidify", "path", agent_workbook_solidify),
|
|
("agent_kb_task_files", "kb_dir,goal", agent_kb_task_files),
|
|
("agent_memory_ensure", "memory_dir", agent_memory_ensure),
|
|
("agent_record_episode", "task,status,result,mode", agent_record_episode),
|
|
("agent_list_episodes", "memory_dir,task", agent_list_episodes),
|
|
("agent_get_episode", "id", agent_get_episode),
|
|
("agent_cluster_episodes", "memory_dir,task,threshold", agent_cluster_episodes),
|
|
("agent_extract_pattern", "task", agent_extract_pattern),
|
|
("agent_generalize", "task", agent_generalize),
|
|
("agent_synthesize_skill", "task", agent_synthesize_skill),
|
|
("agent_compile_skill", "task,kb_dir,min_evidence", agent_compile_skill),
|
|
("agent_maybe_learn", "task,kb_dir,improve_every", agent_maybe_learn),
|
|
("agent_metrics", "memory_dir", agent_metrics),
|
|
("agent_resolve", "task,kb_dir", agent_resolve),
|
|
("agent_route", "task,backend,kb_dir,memory_dir", agent_route),
|
|
("agent_route_apply", "task,reply,kb_dir", agent_route_apply),
|
|
("agent_compile_policy", "memory_dir,min_evidence", agent_compile_policy),
|
|
("agent_maybe_compile_policy", "memory_dir,min_evidence", agent_maybe_compile_policy),
|
|
("agent_eng_preflight", "task", agent_eng_preflight),
|
|
("agent_eng_reuse", "task", agent_eng_reuse),
|
|
("agent_eng_bind_execute", "project,query,policy", agent_eng_bind_execute),
|
|
("agent_eng_publish_gate", "project,artifact_id,candidate_only", agent_eng_publish_gate),
|
|
("agent_eng_record", "decision", agent_eng_record),
|
|
("sandbox_open", "", sandbox::sandbox_open),
|
|
("sandbox_write", "", sandbox::sandbox_write),
|
|
("sandbox_read", "", sandbox::sandbox_read),
|
|
("sandbox_remove", "", sandbox::sandbox_remove),
|
|
("sandbox_diff", "", sandbox::sandbox_diff),
|
|
("sandbox_commit", "", sandbox::sandbox_commit),
|
|
("sandbox_discard", "", sandbox::sandbox_discard),
|
|
("sandbox_inspect", "", sandbox::sandbox_inspect),
|
|
("sandbox_run", "", sandbox::sandbox_run),
|
|
];
|
|
init_plugin(host, regs)
|
|
}
|
|
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn marqdo_plugin_shutdown() {
|
|
HOST_ALLOC = None;
|
|
HOST_FREE = None;
|
|
HOST_QUERY = None;
|
|
HOST_USERDATA = ptr::null_mut();
|
|
if let Ok(mut map) = HISTORIES.lock() {
|
|
map.clear();
|
|
}
|
|
if let Ok(mut seq) = AGENT_SEQ.lock() {
|
|
*seq = 0;
|
|
}
|
|
}
|