tool_calling_and_web_searching/

tool_calling_and_web_searching.rs

//! Parallel tool-calling agents on the durable tool-call primitive.
//!
//! This example shows the agent pattern the crate is meant to support, built on
//! [`langcontinuation::Continuation::tool_call`] and a registered
//! [`langcontinuation::Tool`]:
//!
//! - The entrypoint forks into two independent research branches.
//! - One branch researches LangChain with Anthropic web search.
//! - The other branch inspects this repository through a client-side text editor
//!   tool.
//! - Both branches write required artifacts into `/work`.
//! - The join step receives both reports as typed environment values and asks
//!   the model to synthesize a final recommendation.
//!
//! The text editor is a single [`Tool`] implementation registered once with
//! [`Trampoline::register_tool`]. The workflow never mounts a filesystem, parses
//! tool JSON, or dispatches tool commands: that all lives in the tool. Each
//! receiver just appends the model turn to its conversation and, when the model
//! calls tools, returns a [`Continuation::tool_call`] suspension that the runtime
//! resolves through the registry. Filesystem policy is explicit in the tool:
//! `/repo` is read-only, `/work` is writable scratch space.
//!
//! Run it live:
//!
//! ```sh
//! cargo run --example tool_calling_and_web_searching
//! ```
//!
//! Or, with `DATABASE_URL` configured, through the Postgres-backed batch
//! executor:
//!
//! ```sh
//! cargo run --features batch --example tool_calling_and_web_searching -- --batch
//! ```

use std::{
    ffi::OsStr,
    future::Future,
    path::{Path, PathBuf},
    pin::Pin,
};

use claudius::{
    Anthropic, ContentBlock, DocumentBlock, FileSystem, KnownModel, Message, MessageCreateParams,
    MessageParam, MessageRole, Model, MountHierarchy, Permissions, PlainTextSource, StopReason,
    TextBlock, ToolResultBlock, ToolTextEditor20250728, ToolUnionParam, ToolUseBlock,
    WebSearchTool20250305,
};
use langcontinuation::{
    __print_llm_output, Continuation, ContinuationChoice, ForkBranch, Tool, ToolCallId, Trampoline,
    Workflow, client_tool_uses, from_env, generate_goto, live::Executor, push_env,
};
use serde::{Deserialize, Serialize};
use utf8path::Path as Utf8Path;

const CONFIG_KEY: &str = "config: RunConfig";
const LANGCHAIN_REPORT_KEY: &str = "langchain_report: BranchOutput";
const LANGCONTINUATION_REPORT_KEY: &str = "langcontinuation_report: BranchOutput";
const FINAL_RECOMMENDATION_KEY: &str = "final_recommendation: BranchOutput";
const BRANCH_TOOL_CALLS: u32 = 8;
const JOIN_TOOL_CALLS: u32 = 4;

#[derive(Clone, Debug, Deserialize, Serialize)]
struct RunConfig {
    user_ask: String,
    repo_root: String,
    root_mount: String,
    work_root: String,
}

/// Durable per-loop state. The mount roots are deliberately absent: the
/// registered [`TextEditorTool`] owns filesystem configuration, so only the
/// conversation, the required artifact, and the tool budget are durable here.
#[derive(Clone, Debug, Deserialize, Serialize)]
struct ToolLoopState {
    messages: Vec<MessageParam>,
    work_root: String,
    required_file: String,
    max_tool_calls: u32,
    tool_calls_used: u32,
    system_prompt: String,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
struct LangChainLoop {
    state: ToolLoopState,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
struct LangContinuationLoop {
    state: ToolLoopState,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
struct JoinLoop {
    state: ToolLoopState,
}

/// Names a `Vec<ToolResultBlock>` for the macro key convention. Distinct
/// parameter names keep each branch's results under a distinct environment key,
/// so fork/join never merges conflicting writes.
#[derive(Clone, Debug, Deserialize, Serialize)]
struct ToolResults(Vec<ToolResultBlock>);

#[derive(Clone, Debug, Deserialize, Serialize)]
struct BranchOutput {
    path: String,
    text: String,
}

/// The single client-side tool for this demo: a mount-backed text editor.
///
/// All filesystem policy lives here. The tool holds the run's mount roots,
/// rebuilds a [`MountHierarchy`] per call, parses the text-editor command, and
/// dispatches it. The workflow code below never touches a filesystem.
struct TextEditorTool {
    repo_root: String,
    root_mount: String,
    work_root: String,
}

impl TextEditorTool {
    fn new(config: &RunConfig) -> Self {
        Self {
            repo_root: config.repo_root.clone(),
            root_mount: config.root_mount.clone(),
            work_root: config.work_root.clone(),
        }
    }

    fn mount(&self) -> Result<MountHierarchy, std::io::Error> {
        let mut hierarchy = MountHierarchy::default();
        hierarchy
            .mount(
                "/".into(),
                Permissions::ReadOnly,
                Utf8Path::from(self.root_mount.clone()).into_owned(),
            )
            .map_err(std::io::Error::other)?;
        hierarchy
            .mount(
                "/repo".into(),
                Permissions::ReadOnly,
                Utf8Path::from(self.repo_root.clone()).into_owned(),
            )
            .map_err(std::io::Error::other)?;
        hierarchy
            .mount(
                "/work".into(),
                Permissions::ReadWrite,
                Utf8Path::from(self.work_root.clone()).into_owned(),
            )
            .map_err(std::io::Error::other)?;
        Ok(hierarchy)
    }
}

impl Tool for TextEditorTool {
    fn name(&self) -> String {
        "str_replace_based_edit_tool".to_string()
    }

    fn to_param(&self) -> ToolUnionParam {
        ToolUnionParam::TextEditor20250728(
            ToolTextEditor20250728::new().with_max_characters(12_000),
        )
    }

    fn call<'a>(
        &'a self,
        id: ToolCallId,
        tool_use: &'a ToolUseBlock,
    ) -> Pin<Box<dyn Future<Output = ToolResultBlock> + Send + 'a>> {
        let tool_use_id = tool_use.id.clone();
        let input = tool_use.input.clone();
        Box::pin(async move {
            // `id` is the durable dedupe key; filesystem edits here are
            // effectively idempotent, so the demo only logs it.
            let _ = id;
            let block = ToolResultBlock::new(tool_use_id);
            let result = match self.mount() {
                Ok(filesystem) => dispatch_text_editor(&filesystem, &input).await,
                Err(err) => Err(err),
            };

            match result {
                Ok(output) => block.with_string_content(output),
                Err(err) => block.with_string_content(err.to_string()).with_error(true),
            }
        })
    }
}

async fn dispatch_text_editor(
    filesystem: &MountHierarchy,
    input: &serde_json::Value,
) -> Result<String, std::io::Error> {
    async {
        #[derive(Deserialize)]
        struct Command {
            command: String,
        }
        let command: Command = serde_json::from_value(input.clone())?;
        match command.command.as_str() {
            "view" => {
                #[derive(Deserialize)]
                struct ViewArgs {
                    path: String,
                    view_range: Option<(u32, u32)>,
                }
                let args: ViewArgs = serde_json::from_value(input.clone())?;
                filesystem.view(&args.path, args.view_range).await
            }
            "str_replace" => {
                #[derive(Deserialize)]
                struct StrReplaceArgs {
                    path: String,
                    old_str: String,
                    new_str: Option<String>,
                }
                let args: StrReplaceArgs = serde_json::from_value(input.clone())?;
                filesystem
                    .str_replace(
                        &args.path,
                        &args.old_str,
                        args.new_str.as_deref().unwrap_or(""),
                    )
                    .await
            }
            "insert" => {
                #[derive(Deserialize)]
                struct InsertArgs {
                    path: String,
                    insert_line: u32,
                    insert_text: Option<String>,
                    new_str: Option<String>,
                }
                let args: InsertArgs = serde_json::from_value(input.clone())?;
                let insert_text = args.insert_text.or(args.new_str).ok_or_else(|| {
                    std::io::Error::new(
                        std::io::ErrorKind::InvalidInput,
                        "insert requires insert_text or new_str",
                    )
                })?;
                filesystem
                    .insert(&args.path, args.insert_line, &insert_text)
                    .await
            }
            "create" => {
                #[derive(Deserialize)]
                struct CreateArgs {
                    path: String,
                    file_text: String,
                }
                let args: CreateArgs = serde_json::from_value(input.clone())?;
                filesystem.create(&args.path, &args.file_text).await
            }
            other => Err(std::io::Error::new(
                std::io::ErrorKind::Unsupported,
                format!("{other} is not supported by the text editor demo"),
            )),
        }
    }
    .await
}

generate_goto! {
    fn entrypoint(workflow: &mut Workflow, config: RunConfig, continuation: Continuation) -> Result<ContinuationChoice, handled::SError> {
        let run_id = workflow.run_id().to_string();
        let _ = config;
        Ok(continuation.fork_join(
            ForkBranch::new(format!("{run_id}:langchain"), "start_langchain_branch"),
            ForkBranch::new(format!("{run_id}:langcontinuation"), "start_langcontinuation_branch"),
            "start_join",
        ))
    }
}

generate_goto! {
    fn start_langchain_branch(workflow: &mut Workflow, config: RunConfig, continuation: Continuation) -> Result<ContinuationChoice, handled::SError> {
        let state = branch_state(
            &config,
            "/work/langchain.md",
            "LangChain research branch",
            format!(
                "Research LangChain for this user request: `{}`.\n\nUse web_search for current public information about LangChain. Use the text editor to create `/work/langchain.md` with a concise report covering what LangChain is, why teams use it, its strengths, and its practical limits.\n\nYou may make at most {BRANCH_TOOL_CALLS} text_editor tool calls in this branch. The web_search tool is available for web research. Do not stop until `/work/langchain.md` exists.",
                config.user_ask
            ),
        );
        push_env!(workflow.langchain_loop: LangChainLoop = LangChainLoop { state });
        Ok(continuation.call("ask_langchain"))
    }
}

generate_goto! {
    fn start_langcontinuation_branch(workflow: &mut Workflow, config: RunConfig, continuation: Continuation) -> Result<ContinuationChoice, handled::SError> {
        let state = branch_state(
            &config,
            "/work/langcontinuation.md",
            "langcontinuation repository branch",
            format!(
                "Inspect the langcontinuation repository for this user request: `{}`.\n\nUse text_editor view/search calls against `/repo` to understand the crate. You may also use web_search if external context is useful, but the repository is the source of truth. Create `/work/langcontinuation.md` with a concise report covering what langcontinuation is, how its continuation model works, what is implemented now, and what promise the tool-calling example should demonstrate.\n\nYou may make at most {BRANCH_TOOL_CALLS} text_editor tool calls in this branch. Do not stop until `/work/langcontinuation.md` exists.",
                config.user_ask
            ),
        );
        push_env!(workflow.langcontinuation_loop: LangContinuationLoop = LangContinuationLoop { state });
        Ok(continuation.call("ask_langcontinuation"))
    }
}

generate_goto! {
    fn ask_langchain(workflow: &mut Workflow, langchain_loop: LangChainLoop, continuation: Continuation) -> Result<ContinuationChoice, handled::SError> {
        let _ = workflow;
        Ok(continuation.anthropic(
            "anthropic",
            anthropic_request(&langchain_loop.state),
            "langchain_response: Message",
            "handle_langchain_response",
        ))
    }
}

generate_goto! {
    fn ask_langcontinuation(workflow: &mut Workflow, langcontinuation_loop: LangContinuationLoop, continuation: Continuation) -> Result<ContinuationChoice, handled::SError> {
        let _ = workflow;
        Ok(continuation.anthropic(
            "anthropic",
            anthropic_request(&langcontinuation_loop.state),
            "langcontinuation_response: Message",
            "handle_langcontinuation_response",
        ))
    }
}

generate_goto! {
    fn handle_langchain_response(
        workflow: &mut Workflow,
        langchain_loop: LangChainLoop,
        langchain_response: Message,
        continuation: Continuation
    ) -> Result<ContinuationChoice, handled::SError> {
        let (state, choice) = receive_response(
            workflow,
            langchain_loop.state,
            langchain_response,
            continuation,
            LANGCHAIN_REPORT_KEY,
            "langchain_results: ToolResults",
            "after_langchain_tools",
        )?;
        push_env!(workflow.langchain_loop: LangChainLoop = LangChainLoop { state });
        Ok(choice)
    }
}

generate_goto! {
    fn handle_langcontinuation_response(
        workflow: &mut Workflow,
        langcontinuation_loop: LangContinuationLoop,
        langcontinuation_response: Message,
        continuation: Continuation
    ) -> Result<ContinuationChoice, handled::SError> {
        let (state, choice) = receive_response(
            workflow,
            langcontinuation_loop.state,
            langcontinuation_response,
            continuation,
            LANGCONTINUATION_REPORT_KEY,
            "langcontinuation_results: ToolResults",
            "after_langcontinuation_tools",
        )?;
        push_env!(workflow.langcontinuation_loop: LangContinuationLoop = LangContinuationLoop { state });
        Ok(choice)
    }
}

generate_goto! {
    fn after_langchain_tools(
        workflow: &mut Workflow,
        langchain_loop: LangChainLoop,
        langchain_results: ToolResults,
        continuation: Continuation
    ) -> Result<ContinuationChoice, handled::SError> {
        let mut state = langchain_loop.state;
        thread_tool_results(&mut state, langchain_results);
        push_env!(workflow.langchain_loop: LangChainLoop = LangChainLoop { state });
        Ok(continuation.call("ask_langchain"))
    }
}

generate_goto! {
    fn after_langcontinuation_tools(
        workflow: &mut Workflow,
        langcontinuation_loop: LangContinuationLoop,
        langcontinuation_results: ToolResults,
        continuation: Continuation
    ) -> Result<ContinuationChoice, handled::SError> {
        let mut state = langcontinuation_loop.state;
        thread_tool_results(&mut state, langcontinuation_results);
        push_env!(workflow.langcontinuation_loop: LangContinuationLoop = LangContinuationLoop { state });
        Ok(continuation.call("ask_langcontinuation"))
    }
}

generate_goto! {
    fn start_join(
        workflow: &mut Workflow,
        langchain_report: BranchOutput,
        langcontinuation_report: BranchOutput,
        continuation: Continuation
    ) -> Result<ContinuationChoice, handled::SError> {
        let config: RunConfig = workflow
            .from_env(CONFIG_KEY)
            .map_err(|err| langcontinuation::env_decode_error(CONFIG_KEY, err))?
            .ok_or_else(|| langcontinuation::missing_env_error(CONFIG_KEY))?;

        let instruction = format!(
            "Synthesize these two branch reports for the user request: `{}`.\n\nUse the text editor to create `/work/recommendation.md`. Recommend the highest-impact improvement to make the repository's promise land better, and explain why this live fork/join tool-calling demo is the right next investment. You may make at most {JOIN_TOOL_CALLS} text_editor tool calls in this join step. Do not stop until `/work/recommendation.md` exists.",
            config.user_ask
        );
        let messages = vec![MessageParam::new_with_blocks(
            vec![
                ContentBlock::Text(TextBlock::new(instruction)),
                ContentBlock::Document(
                    DocumentBlock::new_with_plain_text(PlainTextSource::new(langchain_report.text))
                        .with_title("LangChain branch report".to_string()),
                ),
                ContentBlock::Document(
                    DocumentBlock::new_with_plain_text(PlainTextSource::new(
                        langcontinuation_report.text,
                    ))
                    .with_title("langcontinuation branch report".to_string()),
                ),
            ],
            MessageRole::User,
        )];
        let state = ToolLoopState {
            messages,
            work_root: config.work_root,
            required_file: "/work/recommendation.md".to_string(),
            max_tool_calls: JOIN_TOOL_CALLS,
            tool_calls_used: 0,
            system_prompt: system_prompt("join synthesis"),
        };

        push_env!(workflow.join_loop: JoinLoop = JoinLoop { state });
        Ok(continuation.call("ask_join"))
    }
}

generate_goto! {
    fn ask_join(workflow: &mut Workflow, join_loop: JoinLoop, continuation: Continuation) -> Result<ContinuationChoice, handled::SError> {
        let _ = workflow;
        Ok(continuation.anthropic(
            "anthropic",
            anthropic_request(&join_loop.state),
            "join_response: Message",
            "handle_join_response",
        ))
    }
}

generate_goto! {
    fn handle_join_response(
        workflow: &mut Workflow,
        join_loop: JoinLoop,
        join_response: Message,
        continuation: Continuation
    ) -> Result<ContinuationChoice, handled::SError> {
        let (state, choice) = receive_response(
            workflow,
            join_loop.state,
            join_response,
            continuation,
            FINAL_RECOMMENDATION_KEY,
            "join_results: ToolResults",
            "after_join_tools",
        )?;
        push_env!(workflow.join_loop: JoinLoop = JoinLoop { state });
        Ok(choice)
    }
}

generate_goto! {
    fn after_join_tools(
        workflow: &mut Workflow,
        join_loop: JoinLoop,
        join_results: ToolResults,
        continuation: Continuation
    ) -> Result<ContinuationChoice, handled::SError> {
        let mut state = join_loop.state;
        thread_tool_results(&mut state, join_results);
        push_env!(workflow.join_loop: JoinLoop = JoinLoop { state });
        Ok(continuation.call("ask_join"))
    }
}

fn branch_state(
    config: &RunConfig,
    required_file: &str,
    branch_name: &str,
    task: String,
) -> ToolLoopState {
    ToolLoopState {
        messages: vec![MessageParam::user(task)],
        work_root: config.work_root.clone(),
        required_file: required_file.to_string(),
        max_tool_calls: BRANCH_TOOL_CALLS,
        tool_calls_used: 0,
        system_prompt: system_prompt(branch_name),
    }
}

fn system_prompt(branch_name: &str) -> String {
    let prompt = format!(
        "You are running inside the langcontinuation tool-calling demo, in the {branch_name} step.\n\nAvailable filesystem mounts:\n- `/repo` is the langcontinuation repository mounted read-only.\n- `/work` is writable scratch space for report artifacts.\n\nUse web_search for external facts and the text editor for filesystem reads/writes. Text editor calls are executed by the Rust workflow; web_search is Anthropic server-side. Respect the explicit tool-call budget in the user message. When you are done, stop only after the required `/work/...` file exists."
    );
    prompt
}

fn anthropic_request(state: &ToolLoopState) -> MessageCreateParams {
    // The text editor is a registered client-side tool; web search is server
    // side. Both are advertised to the model here.

    MessageCreateParams::new(
        4096,
        state.messages.clone(),
        Model::Known(KnownModel::ClaudeSonnet45),
    )
    .with_system_string(state.system_prompt.clone())
    .with_tools(vec![
        ToolUnionParam::TextEditor20250728(
            ToolTextEditor20250728::new().with_max_characters(12_000),
        ),
        ToolUnionParam::WebSearch20250305(WebSearchTool20250305::new().with_max_uses(4)),
    ])
}

/// Receive a model response and choose the next durable step.
///
/// This is the whole agent loop body now: append the assistant turn, and either
/// suspend to run the called tools (the runtime resolves them through the
/// registry) or, when the model is done, read the required artifact and halt.
/// There is no mounting, JSON parsing, or tool dispatch here — that lives in
/// [`TextEditorTool`].
#[allow(clippy::too_many_arguments)]
fn receive_response(
    workflow: &mut Workflow,
    mut state: ToolLoopState,
    response: Message,
    continuation: Continuation,
    output_key: &str,
    results_key: &str,
    after_function: &str,
) -> Result<(ToolLoopState, ContinuationChoice), handled::SError> {
    (|| {
        state.messages.push(MessageParam::from(response.clone()));

        let tool_uses = client_tool_uses(&response);
        if !tool_uses.is_empty() {
            let requested = tool_uses.len() as u32;
            if state.tool_calls_used.saturating_add(requested) > state.max_tool_calls {
                return Err(demo_error(
                    "tool-call-budget-exhausted",
                    "model exceeded the text_editor tool-call budget",
                )
                .with_string_field("required_file", &state.required_file)
                .with_atom_field("max_tool_calls", state.max_tool_calls)
                .with_atom_field("tool_calls_used", state.tool_calls_used)
                .with_atom_field("requested_tool_calls", requested));
            }
            state.tool_calls_used += requested;
            // Suspend: the runtime runs each tool_use through the registered
            // tool and resumes at `after_function` with the results.
            return Ok((
                state,
                continuation.tool_call(tool_uses, results_key, after_function),
            ));
        }

        if matches!(response.stop_reason, Some(StopReason::ToolUse)) {
            return Err(demo_error(
                "unsupported-tool-use",
                "model requested tool use but no client-side text editor tool call was present",
            )
            .with_string_field("required_file", &state.required_file));
        }

        let output = read_required_output(&state)?;
        workflow
            .into_env(output_key, output)
            .map_err(|err| langcontinuation::env_encode_error(output_key, err))?;
        Ok((state, continuation.halt()))
    })()
}

/// Thread tool results back into the conversation as the next user message.
fn thread_tool_results(state: &mut ToolLoopState, results: ToolResults) {
    let blocks: Vec<ContentBlock> = results
        .0
        .into_iter()
        .map(ContentBlock::ToolResult)
        .collect();
    state
        .messages
        .push(MessageParam::new_with_blocks(blocks, MessageRole::User));
}

fn read_required_output(state: &ToolLoopState) -> Result<BranchOutput, handled::SError> {
    (|| {
        let path = virtual_work_path(&state.work_root, &state.required_file)?;
        let text = std::fs::read_to_string(&path).map_err(|err| {
            demo_error(
                "required-output-missing",
                "model stopped before creating the required output file",
            )
            .with_string_field("required_file", &state.required_file)
            .with_string_field("source", &err.to_string())
        })?;
        if text.trim().is_empty() {
            return Err(demo_error(
                "required-output-empty",
                "model created the required output file but left it empty",
            )
            .with_string_field("required_file", &state.required_file));
        }
        Ok(BranchOutput {
            path: path.display().to_string(),
            text,
        })
    })()
}

fn virtual_work_path(work_root: &str, virtual_path: &str) -> Result<PathBuf, handled::SError> {
    (|| {
        let relative = virtual_path.strip_prefix("/work/").ok_or_else(|| {
            demo_error(
                "invalid-required-file",
                "required output path must be inside the /work mount",
            )
            .with_string_field("required_file", virtual_path)
        })?;
        Ok(Path::new(work_root).join(relative))
    })()
}

fn demo_error(code: &str, message: &str) -> handled::SError {
    handled::SError::new("tool-calling-and-web-searching")
        .with_code(code)
        .with_message(message)
}

fn register_workflow(config: &RunConfig) -> Trampoline {
    let mut trampoline = Trampoline::default();
    trampoline.register("entrypoint", entrypoint);
    trampoline.register("start_langchain_branch", start_langchain_branch);
    trampoline.register(
        "start_langcontinuation_branch",
        start_langcontinuation_branch,
    );
    trampoline.register("ask_langchain", ask_langchain);
    trampoline.register("ask_langcontinuation", ask_langcontinuation);
    trampoline.register("handle_langchain_response", handle_langchain_response);
    trampoline.register(
        "handle_langcontinuation_response",
        handle_langcontinuation_response,
    );
    trampoline.register("after_langchain_tools", after_langchain_tools);
    trampoline.register("after_langcontinuation_tools", after_langcontinuation_tools);
    trampoline.register("start_join", start_join);
    trampoline.register("ask_join", ask_join);
    trampoline.register("handle_join_response", handle_join_response);
    trampoline.register("after_join_tools", after_join_tools);
    // One registered tool serves every branch and the join.
    trampoline.register_tool(TextEditorTool::new(config));
    trampoline
}

#[cfg(feature = "batch")]
async fn run_batch_executor(
    trampoline: Trampoline,
    workflow: Workflow,
    anthropic: Anthropic,
    database_url: &str,
) -> Result<Workflow, Box<dyn std::error::Error>> {
    let result = async {
        let run_id = workflow.run_id().to_string();
        let pool = sqlx::PgPool::connect(database_url).await?;
        langcontinuation::batch::migrate(&pool).await?;
        let executor = langcontinuation::batch::Executor::with_default_config(trampoline, pool)
            .with_anthropic("anthropic", anthropic);
        executor.enqueue_workflow(workflow).await?;
        let _summary = executor.run().await?;
        let record = executor.load_workflow(&run_id).await?.ok_or_else(|| {
            demo_error(
                "batch-workflow-missing",
                "batch executor did not persist the workflow row",
            )
            .with_string_field("run_id", &run_id)
        })?;
        match record.status {
            langcontinuation::batch::WorkflowStatus::Halted => Ok(record.workflow),
            langcontinuation::batch::WorkflowStatus::Failed => {
                Err(demo_error("batch-workflow-failed", "batch workflow failed")
                    .with_string_field("run_id", &run_id)
                    .with_string_field("source", record.error_sexpr.as_deref().unwrap_or("unknown"))
                    .into())
            }
            status => Err(demo_error(
                "batch-workflow-incomplete",
                "batch executor stopped before the workflow halted",
            )
            .with_string_field("run_id", &run_id)
            .with_atom_field("status", status.as_str())
            .into()),
        }
    }
    .await;
    result
}

#[cfg(not(feature = "batch"))]
async fn run_batch_executor(
    _trampoline: Trampoline,
    _workflow: Workflow,
    _anthropic: Anthropic,
    _database_url: &str,
) -> Result<Workflow, Box<dyn std::error::Error>> {
    Err(demo_error(
        "batch-feature-disabled",
        "rebuild the example with `--features batch` to use --batch with DATABASE_URL",
    )
    .into())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    async {
        let batch_requested = std::env::args_os()
            .skip(1)
            .any(|arg| arg == OsStr::new("--batch"));
        let database_url = std::env::var("DATABASE_URL").ok();
        if batch_requested && database_url.is_some() && !cfg!(feature = "batch") {
            return Err(demo_error(
                "batch-feature-disabled",
                "rebuild the example with `--features batch` to use --batch with DATABASE_URL",
            )
            .into());
        }
        let run_nanos = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)?
            .as_nanos();
        let run_id = format!("tool-demo-{}-{run_nanos}", std::process::id());
        let repo_root = std::env::current_dir()?;
        let demo_root = repo_root
            .join("target")
            .join("langcontinuation-tool-demo")
            .join(&run_id);
        let root_mount = demo_root.join("root");
        let work_root = demo_root.join("work");
        std::fs::create_dir_all(&root_mount)?;
        std::fs::create_dir_all(&work_root)?;

        let config = RunConfig {
            user_ask: "Tell me about langchain and langcontinuation?".to_string(),
            repo_root: repo_root.display().to_string(),
            root_mount: root_mount.display().to_string(),
            work_root: work_root.display().to_string(),
        };

        let mut workflow = Workflow::new(run_id, "entrypoint");
        push_env!(workflow.config: RunConfig = config.clone());

        let trampoline = register_workflow(&config);

        let anthropic = Anthropic::new(None)?;
        let workflow = match (batch_requested, database_url.as_deref()) {
            (true, Some(database_url)) => {
                run_batch_executor(trampoline, workflow, anthropic, database_url).await?
            }
            _ => {
                let executor = Executor::new(trampoline).with_anthropic("anthropic", anthropic);
                executor.run_workflow(workflow).await?
            }
        };

        from_env!(let final_recommendation: BranchOutput = workflow.lookup());
        __print_llm_output(&final_recommendation.text);
        println!("\nWrote {}", final_recommendation.path);
        Ok(())
    }
    .await
}