ScenarioExecutor.cs

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

using System.Text.Json;
using Lilith.Core.Tools;

namespace Lilith.Core.Scenarios;

public sealed record ScenarioRunResult(string RunId, string ScenarioId, string Output, string ExitMode, string ExitRequest, Lilith.Core.Workspace.WorkspaceResult? Workspace = null, Lilith.Core.Scheduling.ScheduleResult? Schedule = null);
public sealed class ScenarioExecutionException(string runId, Exception inner)
    : Exception(inner.Message, inner)
{
    public string RunId { get; } = runId;
}

public sealed class ScenarioExecutor(ProviderClient parent)
{
    /// <summary>Application API for trusted full XML. Model calls should use the saved-file scenario tool.</summary>
    public async Task<ScenarioRunResult> RunXmlAsync(string completeXml, CancellationToken cancellationToken = default)
    {
        cancellationToken.ThrowIfCancellationRequested();
        var scenario = ScenarioXmlParser.Parse(completeXml);
        string[] missing = scenario.Inputs.Where(i => i.Required && string.IsNullOrWhiteSpace(i.Value)).Select(i => i.Name).ToArray();
        if (missing.Length > 0) throw new ArgumentException("Missing required scenario inputs: " + string.Join(", ", missing));
        var values = scenario.Inputs.ToDictionary(i => i.Name, i => i.Value ?? string.Empty, StringComparer.Ordinal);
        // Validate every substitution/tool reference before compiling code or running a chat turn.
        string prompt = ScenarioXmlParser.Expand(scenario.SystemPrompt, values);
        string[] steps = scenario.Steps.Select(s => ScenarioXmlParser.Expand(s, values)).ToArray();
        string exit = ScenarioXmlParser.Expand(scenario.ExitRequest, values);
        var workspaceNames = scenario.AllowedTools.Where(n => Lilith.Core.Workspace.WorkspaceTool.Operation(n) is not null).ToArray();
        var scheduleNames = scenario.AllowedTools.Where(n => Lilith.Core.Scheduling.ScheduleTool.Operation(n) is not null).ToArray();
        if (scheduleNames.Length > 0 && (parent.Schedules is null || parent.ExecutingScheduledJob || scenario.Steps.Length != 1 || scenario.AllowedTools.Length != 1 || scenario.CodeTools.Length != 0))
            throw new InvalidDataException("Schedule scenarios require a configured scheduler, one step, one schedule operation and no embedded code; scheduled jobs cannot manage schedules.");
        if (workspaceNames.Length > 0 && (parent.Workspace is null || scenario.Steps.Length != 1 || scenario.AllowedTools.Length != 1 || scenario.CodeTools.Length != 0))
            throw new InvalidDataException("Workspace scenarios require a configured workspace, one step, one workspace operation, and no embedded code.");
        foreach (string tool in scenario.AllowedTools)
            if (!workspaceNames.Contains(tool) && !scheduleNames.Contains(tool) && (!parent.RegisteredTools.ContainsKey(tool) || parent.RegisteredTools[tool] is ITurnResultTool))
                throw new InvalidDataException("Unavailable or nested scenario tool: " + tool);
        string runId = Guid.NewGuid().ToString("N");
        string folder = Path.Combine(parent.HistoryStore.RootDirectory, "Scenarios", runId);
        Directory.CreateDirectory(folder);
        using var transcript = new StreamWriter(Path.Combine(folder, "session.log")) { AutoFlush = true };
        await File.WriteAllTextAsync(Path.Combine(folder, "scenario.xml"), completeXml, cancellationToken);
        void Report(string kind, string text, int step)
        {
            transcript.WriteLine($"{DateTimeOffset.UtcNow:O} [{kind}] {text}");
            parent.ReportScenario(new ScenarioProgress(runId, scenario.Id, kind, text, step, steps.Length));
        }
        Report("Started", scenario.Title, 0);
        using var deadline = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
        deadline.CancelAfter(TimeSpan.FromMinutes(10));
        var ct = deadline.Token;
        try
        {
            using var compiler = await ScenarioCodeCompiler.CompileAsync(scenario.CodeTools, values, ct);
            using var child = parent.CreateScenarioBranch(prompt, new Logger(), new ChatHistoryStore(Path.Combine(folder, "History")));
            child.AgentName = "Scenario:" + scenario.Id;
            Lilith.Core.Workspace.WorkspaceResult? storageResult = null;
            Lilith.Core.Scheduling.ScheduleResult? scheduleResult = null;
            foreach (string name in scenario.AllowedTools)
            {
                if (workspaceNames.Contains(name)) child.RegisterTool(new Lilith.Core.Workspace.WorkspaceTool(parent.Workspace!, Lilith.Core.Workspace.WorkspaceTool.Operation(name)!, values, result => storageResult = result));
                else if (scheduleNames.Contains(name)) child.RegisterTool(new Lilith.Core.Scheduling.ScheduleTool(parent.Schedules!, Lilith.Core.Scheduling.ScheduleTool.Operation(name)!, values, result => scheduleResult = result));
                else child.RegisterTool(parent.RegisteredTools[name]);
            }
            foreach (var tool in compiler.Tools) child.RegisterTool(tool);
            string? last = null;
            for (int i = 0; i < steps.Length; i++)
            {
                ct.ThrowIfCancellationRequested();
                Report("Step", $"{i + 1}/{steps.Length}: {steps[i]}", i + 1);
                int historyCount = child.History.Count;
                last = await child.StreamReply(steps[i], cancellationToken: ct);
                foreach (var toolResult in child.History.Skip(historyCount).Where(m => m.Role == "tool"))
                    Report("Tool", toolResult.ToolName + ": " + toolResult.Content, i + 1);
                Report("Reply", last, i + 1);
            }
            ct.ThrowIfCancellationRequested();
            if (string.IsNullOrWhiteSpace(last)) throw new InvalidDataException("Scenario produced no final response.");
            if (workspaceNames.Length > 0 && storageResult is null) throw new InvalidDataException("The scenario did not perform its workspace operation. No completion is claimed.");
            if (scheduleNames.Length > 0 && scheduleResult is null) throw new InvalidDataException("The scenario did not perform its schedule operation. No completion is claimed.");
            var result = new ScenarioRunResult(runId, scenario.Id, last, scenario.ExitMode, exit, storageResult, scheduleResult);
            await File.WriteAllTextAsync(Path.Combine(folder, "result.json"), JsonSerializer.Serialize(result, new JsonSerializerOptions { WriteIndented = true }), ct);
            Report(storageResult?.Status == "needs_approval" || scheduleResult?.Status == "needs_approval" ? "NeedsApproval" : "Completed", "Result returned to caller.", steps.Length);
            return result;
        }
        catch (Exception ex)
        {
            await File.WriteAllTextAsync(Path.Combine(folder, "failure.json"), JsonSerializer.Serialize(new
            {
                RunId = runId, ScenarioId = scenario.Id, Status = ex is OperationCanceledException ? "canceled" : "failed", Error = ex.Message
            }));
            Report(ex is OperationCanceledException ? "Canceled" : "Failed", ex.Message, 0);
            if (ex is OperationCanceledException) throw;
            throw new ScenarioExecutionException(runId, ex);
        }
    }
}