zesdex/src/tool/workflow.rs

use serde_json::{json, Value};
use anyhow::{Result, anyhow};
use super::Tool;
use super::ToolCtx;

pub struct WorkflowRun;

impl Tool for WorkflowRun {
    fn name(&self) -> &'static str {
        "workflow_run"
    }

    fn description(&self) -> &'static str {
        "Execute a workflow script that can spawn multiple subagents in parallel, pipeline, or phased stages. Use when a task benefits from decomposition into independent subtasks. Simple tasks should be handled inline without this tool."
    }

    fn parameters(&self) -> Value {
        json!({
            "type": "object",
            "properties": {
                "script": {
                    "type": "string",
                    "description": "JSON-encoded workflow script with name, description, script (Agent/Parallel/Pipeline/Phase primitives), and options (max_concurrency, continue_on_error)"
                },
                "args": {
                    "type": "object",
                    "description": "Optional string key-value arguments passed to the workflow script for template substitution ({{key}} placeholders)"
                }
            },
            "required": ["script"]
        })
    }

    fn run(&self, _ctx: &ToolCtx, args: &Value) -> Result<String> {
        let script_str = args.get("script")
            .and_then(|v| v.as_str())
            .ok_or_else(|| anyhow!("missing required argument: script"))?;

        let workflow_script: crate::app::workflow::script::WorkflowScript =
            serde_json::from_str(script_str)
                .map_err(|e| anyhow!("failed to parse workflow script: {}", e))?;

        let workflow_args: std::collections::HashMap<String, String> = args.get("args")
            .and_then(|v| v.as_object())
            .map(|obj| {
                obj.iter().filter_map(|(k, v)| {
                    v.as_str().map(|s| (k.clone(), s.to_string()))
                }).collect()
            })
            .unwrap_or_default();

        crate::app::workflow::engine::run_workflow(&workflow_script, &workflow_args)
    }
}

pub struct NoteFinding;

impl Tool for NoteFinding {
    fn name(&self) -> &'static str {
        "note_finding"
    }

    fn description(&self) -> &'static str {
        "Share a finding with sibling agents in the same workflow_run. Findings are ephemeral to the current run and will be prepended to other agents' next tool-round context. Does not persist to memory."
    }

    fn parameters(&self) -> Value {
        json!({
            "type": "object",
            "properties": {
                "text": {
                    "type": "string",
                    "description": "The finding to share with sibling agents"
                }
            },
            "required": ["text"]
        })
    }

    fn run(&self, _ctx: &ToolCtx, args: &Value) -> Result<String> {
        let text = args.get("text")
            .and_then(|v| v.as_str())
            .ok_or_else(|| anyhow!("missing required argument: text"))?;

        crate::app::workflow::engine::note_finding(text);
        Ok(format!("finding recorded: {}", text.chars().take(80).collect::<String>()))
    }
}