sim-lib-agent 0.1.1

Agent runtime surfaces for SIM.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use std::sync::Arc;

use sim_kernel::{
    CapabilityName, Cx, ExportKind, ExportRecord, ExportState, Result, RuntimeId, Symbol,
};
use sim_shape::{AnyShape, ListShape, shape_value};

use crate::{AGENT_LIB_ID, Tool, ToolSpec, install_tool};

pub(crate) fn install_cookbook_tools(cx: &mut Cx) -> Result<()> {
    sim_lib_cookbook::install_seeded_cookbook_lib(cx)?;
    let search_tool = cookbook_tool(cx, "search", "search seeded cookbook recipes", Vec::new())?;
    install_tool(cx, Arc::new(search_tool))?;
    let run_tool = cookbook_tool(
        cx,
        "run",
        "run a seeded cookbook recipe with expectation checks",
        vec![sim_kernel::read_eval_capability()],
    )?;
    install_tool(cx, Arc::new(run_tool))?;
    install_cookbook_card(cx)
}

fn cookbook_tool(
    cx: &mut Cx,
    name: &str,
    description: &str,
    capabilities: Vec<CapabilityName>,
) -> Result<Tool> {
    let function = cx.resolve_function(&Symbol::qualified("cookbook", name))?;
    Ok(Tool::local(
        cx,
        ToolSpec {
            symbol: Symbol::qualified("agent", format!("cookbook-{name}")),
            description: description.to_owned(),
            args_shape: one_arg_shape(name),
            result_shape: Some(any_shape(&format!("{name}-result"))),
            category: Symbol::new("cookbook"),
            capabilities,
            function,
        },
    ))
}

fn install_cookbook_card(cx: &mut Cx) -> Result<()> {
    let symbol = Symbol::qualified("agent", "cookbook");
    if cx.registry().value_by_symbol(&symbol).is_some() {
        return Ok(());
    }
    let search = cx
        .factory()
        .symbol(Symbol::qualified("agent", "cookbook-search"))?;
    let run = cx
        .factory()
        .symbol(Symbol::qualified("agent", "cookbook-run"))?;
    let value = cx.factory().table(vec![
        (
            Symbol::new("kind"),
            cx.factory()
                .symbol(Symbol::qualified("agent", "cookbook"))?,
        ),
        (Symbol::new("name"), cx.factory().symbol(symbol.clone())?),
        (
            Symbol::new("description"),
            cx.factory().string(
                "agent cookbook surface backed by cookbook:search and cookbook:run".to_owned(),
            )?,
        ),
        (
            Symbol::new("category"),
            cx.factory().symbol(Symbol::new("cookbook"))?,
        ),
        (Symbol::new("search"), search.clone()),
        (Symbol::new("run"), run.clone()),
        (Symbol::new("tools"), cx.factory().list(vec![search, run])?),
    ])?;
    cx.registry_mut()
        .register_value_for_lib(&Symbol::new(AGENT_LIB_ID), symbol.clone(), value)?;
    cx.registry_mut().append_export_record(
        &Symbol::new(AGENT_LIB_ID),
        ExportRecord {
            kind: ExportKind::new(Symbol::new("card")),
            symbol,
            state: ExportState::Resolved {
                id: RuntimeId::Value,
            },
        },
    )
}

fn one_arg_shape(name: &str) -> sim_kernel::ShapeRef {
    shape_value(
        Symbol::qualified("agent/cookbook", format!("{name}-args")),
        Arc::new(ListShape::new(vec![Arc::new(AnyShape)])),
    )
}

fn any_shape(name: &str) -> sim_kernel::ShapeRef {
    shape_value(
        Symbol::qualified("agent/cookbook", name.to_owned()),
        Arc::new(AnyShape),
    )
}