Run code a model wrote

using System.Text.Json;
using RecursiveAI.OneEcma;
using RecursiveAI.OneEcma.Diagnostics;
 
// What a tool-calling host does with code a model wrote: check it, run it as an async function body
// under limits, and hand back either the result or a compact report the model can act on.
static string RunModelCode(string code)
{
    // Every syntax error at once, before anything runs. Repairs are syntax-only and never change meaning.
    RepairResult repaired = ScriptEngine.CheckAndRepairAsyncBody(code, "tool.js");
    if (repaired.Diagnostics.Count > 0)
        return DiagnosticRenderer.RenderAll(repaired.Diagnostics, new RenderOptions { Compact = true });
    string notes = repaired.Changed
        ? DiagnosticRenderer.RenderRepairs(repaired.Repairs, [], new RenderOptions { Compact = true }) + "\n"
        : "";
 
    var engine = new ScriptEngine(new ScriptEngineOptions
    {
        Limits = new EngineLimits { Fuel = 10_000_000, WallClockMs = 2_000, MaxAllocatedBytes = 64 << 20 },
        Configure = e => e.MainRealm.DefineData(e.Global, "orders", JsValue.FromObject(JsonSchemaTools.DefineAsync(e.MainRealm, "orders",
            """{ "type": "object", "required": ["customer"], "properties": { "customer": { "type": "string" } } }""",
            _ => Task.FromResult(JsonSerializer.SerializeToElement(new[]
            {
                new { id = 1, total = 12.5, shipped = true },
                new { id = 2, total = 40.0, shipped = false },
            })))), JsAttributes.Method),
    });
    try
    {
        JsValue result = engine.Await(engine.EvaluateAsyncBody(repaired.RepairedSource, "tool.js"));
        return notes + "result: " + engine.ToDisplayString(result);
    }
    catch (JsException e)
    {
        return notes + DiagnosticRenderer.Render(e.Report!, new RenderOptions { Compact = true });
    }
    catch (JsLimitException e)
    {
        return notes + DiagnosticRenderer.Render(e.Report!, new RenderOptions { Compact = true });
    }
}
 
string[] attempts =
[
    // First try: the model guessed the result's shape.
    """
    const res = await orders({ customer: "harbor" });
    const open = res.orders.filter(o => !o.shipped);
    return open.map(o => o.id).join(", ");
    """,
    // Second try, after reading the report.
    """
    const list = await orders({ customer: "harbor" });
    const open = list.filter(o => !o.shipped);
    return open.map(o => o.id).join(", ");
    """,
    // A typo the repair table fixes.
    """
    const list = await orders({ customer: "harbor" });
    return list.map(o => o.total).reduce((a, b) => a + b, 0));
    """,
    // A call the tool's schema rejects.
    """
    return (await orders({ customer: 7 })).length;
    """,
];
foreach (string code in attempts)
{
    Console.WriteLine(RunModelCode(code));
    Console.WriteLine();
}

error[TypeError]: Cannot read properties of undefined (reading 'filter')
 --> tool.js:2:18
1 | const res = await orders({ customer: "harbor" });
  |             ------------------------------------ `res` comes from here: Array (2 items)
2 | const open = res.orders.filter(o => !o.shipped);
  |                  ^^^^^^ `res.orders` is undefined
  = help: guard it: `res.orders?.filter`
 
 
result: 2
 
repair[R001]: removed an extra closing delimiter
 --> tool.js:2:57
2 | return list.map(o => o.total).reduce((a, b) => a + b, 0));
  |                                                         ^ removed
 
result: 52.5
 
error[TypeError]: orders: argument 'args.customer' must be a string, got number 7
 --> tool.js:1:15
1 | return (await orders({ customer: 7 })).length;
  |               ^^^^^^ `args.customer` is number 7, expected a string
  = help: convert it first: String(value)
  = stack: orders [.NET] ← <top-level> (tool.js:1)