Only the delta.

1
2
3
4

<Project>
  <!-- V9 personality profiles. V8 is preserved as v8-before-v9. -->
  <PropertyGroup><VersionPrefix>9.0.0</VersionPrefix><VersionSuffix>alpha.1</VersionSuffix></PropertyGroup>
</Project>

1
2
3
4

<Project>
  <!-- V8 local-browser web research. V7 is preserved separately. -->
  <PropertyGroup><VersionPrefix>8.0.0</VersionPrefix><VersionSuffix>alpha.1</VersionSuffix></PropertyGroup>
</Project>

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

using System;
using System.Text;
using System.Threading.Tasks;
using Lilith.Core.Logging;
using Lilith.Agent;
using LilithAgent = Lilith.Agent;
using LilithConsole.Setup;
using Lilith.Core.Kokoro;

namespace LilithConsole
{
    partial class Program
    {
        static async Task Main(string[] args)
        {
            Console.OutputEncoding = Encoding.UTF8;
            var consoleSink = new TextLogSink(Console.Out, overwriteProgress: !Console.IsOutputRedirected,
                width: () => Math.Max(Console.WindowWidth - 1, 1));
            Action<LogEntry> onLog = consoleSink.Handle;

            var logger = new Logger(onLog);
            try
            {
                string settingsPath = Environment.GetEnvironmentVariable("LILITH_CONSOLE_SETTINGS")
                    ?? System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Lilith", "console-settings.json");
                var credentials = await ProviderSetup.RunAsync(Console.In, Console.Out, logger, settingsPath);
                if (credentials is null) { logger.SystemWriteLine("Setup stopped. Relaunch to continue."); return; }
                if (!Console.IsInputRedirected || Environment.GetEnvironmentVariable("LILITH_TTS") == "1")
                {
                    try
                    {
                        credentials = credentials with { Tts = await KokoroSetup.RunAsync(Console.In, Console.Out,
                            logger, settingsPath + ".kokoro.json") };
                    }
                    catch (Exception ex) { logger.SystemWriteLine($"Speech setup failed: {ex.Message}. Relaunch to retry; continuing with text chat.", LogColors.Orange); }
                }
                Console.Title = $"{credentials.AgentName} — {credentials.Model} Chat";
                await using var lilith = new LilithAgent.Lilith(onLog, credentials);
                string mode = "ask";
                if (!Console.IsInputRedirected)
                {
                    Console.Write("Workspace and scheduling mode for this boot [ask/yolo, default ask]: ");
                    mode = Console.ReadLine()?.Trim().ToLowerInvariant() ?? "ask";
                    if (mode.Length == 0) mode = "ask";
                    if (mode is not ("ask" or "yolo")) throw new ArgumentException("Choose ask or yolo at boot.");
                }
                else if (args.Contains("--workspace-yolo")) mode = "yolo";
                var workspace = Lilith.Core.Workspace.WorkspaceOptions.Default;
                string? workspaceRoot = Environment.GetEnvironmentVariable("LILITH_WORKSPACE_ROOT");
                lilith.WorkspaceOptions = workspace with { RootDirectory = workspaceRoot ?? workspace.RootDirectory,
                    Mode = mode == "yolo" ? Lilith.Core.Workspace.WorkspaceAccessMode.Yolo : Lilith.Core.Workspace.WorkspaceAccessMode.Ask };
                Console.WriteLine($"Workspace: {lilith.WorkspaceOptions.RootDirectory} ({mode}, fixed until restart). Use /workspace, /workspace review <id>, /approve <id>, /reject <id>.");
                await lilith.BootAsync(startServerIfNotRunning: true);

                while (true)
                {
                    Console.Title = $"{lilith.Personality.Name} — {credentials.Model} Chat";
                    string? input;
                    using (consoleSink.BeginInput())
                    {
                        lilith.Logger.Write("Input", "You: ", LogColors.Green);
                        input = Console.ReadLine()?.Trim();
                    }
                    if (input is null) break;
                    if (string.IsNullOrEmpty(input)) continue;
                    if (input.Equals("exit", StringComparison.OrdinalIgnoreCase)) break;
                    try
                    {
                        var command = await lilith.ChatCommands.ExecuteAsync(input);
                        if (command.Output is { Length: > 0 }) Console.WriteLine(command.Output);
                        if (command.ExitRequested) break;
                        if (!command.Handled) await lilith.ChatAsync(input);
                    }
                    catch (Exception ex)
                    {
                        lilith.Logger.SystemWriteLine($"Request failed: {ex.Message}. Please try again.", LogColors.Red);
                    }
                }
                await lilith.StopSchedulingAsync();
                lilith.SaveConversation();
                lilith.Logger.SystemWriteLine("Goodbye.");
            }
            catch (Exception ex)
            {
                logger.SystemWriteLine($"Setup/chat failed: {ex.Message}. Relaunch to retry; completed setup steps are retained.", LogColors.Red);
                Environment.ExitCode = 1;
            }
            finally { consoleSink.Flush(); }
        }
    }
}

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

using System;
using System.Text;
using System.Threading.Tasks;
using Lilith.Core.Logging;
using Lilith.Agent;
using LilithAgent = Lilith.Agent;
using LilithConsole.Setup;
using Lilith.Core.Kokoro;

namespace LilithConsole
{
    partial class Program
    {
        static async Task Main(string[] args)
        {
            Console.OutputEncoding = Encoding.UTF8;
            var consoleSink = new TextLogSink(Console.Out, overwriteProgress: !Console.IsOutputRedirected,
                width: () => Math.Max(Console.WindowWidth - 1, 1));
            Action<LogEntry> onLog = consoleSink.Handle;

            var logger = new Logger(onLog);
            try
            {
                string settingsPath = Environment.GetEnvironmentVariable("LILITH_CONSOLE_SETTINGS")
                    ?? System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Lilith", "console-settings.json");
                var credentials = await ProviderSetup.RunAsync(Console.In, Console.Out, logger, settingsPath);
                if (credentials is null) { logger.SystemWriteLine("Setup stopped. Relaunch to continue."); return; }
                if (!Console.IsInputRedirected || Environment.GetEnvironmentVariable("LILITH_TTS") == "1")
                {
                    try
                    {
                        credentials = credentials with { Tts = await KokoroSetup.RunAsync(Console.In, Console.Out,
                            logger, settingsPath + ".kokoro.json") };
                    }
                    catch (Exception ex) { logger.SystemWriteLine($"Speech setup failed: {ex.Message}. Relaunch to retry; continuing with text chat.", LogColors.Orange); }
                }
                Console.Title = $"{credentials.AgentName} — {credentials.Model} Chat";
                await using var lilith = new LilithAgent.Lilith(onLog, credentials);
                string mode = "ask";
                if (!Console.IsInputRedirected)
                {
                    Console.Write("Workspace and scheduling mode for this boot [ask/yolo, default ask]: ");
                    mode = Console.ReadLine()?.Trim().ToLowerInvariant() ?? "ask";
                    if (mode.Length == 0) mode = "ask";
                    if (mode is not ("ask" or "yolo")) throw new ArgumentException("Choose ask or yolo at boot.");
                }
                else if (args.Contains("--workspace-yolo")) mode = "yolo";
                var workspace = Lilith.Core.Workspace.WorkspaceOptions.Default;
                string? workspaceRoot = Environment.GetEnvironmentVariable("LILITH_WORKSPACE_ROOT");
                lilith.WorkspaceOptions = workspace with { RootDirectory = workspaceRoot ?? workspace.RootDirectory,
                    Mode = mode == "yolo" ? Lilith.Core.Workspace.WorkspaceAccessMode.Yolo : Lilith.Core.Workspace.WorkspaceAccessMode.Ask };
                Console.WriteLine($"Workspace: {lilith.WorkspaceOptions.RootDirectory} ({mode}, fixed until restart). Use /workspace, /workspace review <id>, /approve <id>, /reject <id>.");
                await lilith.BootAsync(startServerIfNotRunning: true);

                while (true)
                {
                    string? input;
                    using (consoleSink.BeginInput())
                    {
                        lilith.Logger.Write("Input", "You: ", LogColors.Green);
                        input = Console.ReadLine()?.Trim();
                    }
                    if (input is null) break;
                    if (string.IsNullOrEmpty(input)) continue;
                    if (input.Equals("exit", StringComparison.OrdinalIgnoreCase)) break;
                    try
                    {
                        var command = await lilith.ChatCommands.ExecuteAsync(input);
                        if (command.Output is { Length: > 0 }) Console.WriteLine(command.Output);
                        if (command.ExitRequested) break;
                        if (!command.Handled) await lilith.ChatAsync(input);
                    }
                    catch (Exception ex)
                    {
                        lilith.Logger.SystemWriteLine($"Request failed: {ex.Message}. Please try again.", LogColors.Red);
                    }
                }
                await lilith.StopSchedulingAsync();
                lilith.SaveConversation();
                lilith.Logger.SystemWriteLine("Goodbye.");
            }
            catch (Exception ex)
            {
                logger.SystemWriteLine($"Setup/chat failed: {ex.Message}. Relaunch to retry; completed setup steps are retained.", LogColors.Red);
                Environment.ExitCode = 1;
            }
            finally { consoleSink.Flush(); }
        }
    }
}

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

using Lilith.Core.Logging;
using Lilith.Core.Ollama;

namespace Lilith.Agent;

public partial class Lilith
{
    public bool IsBooted { get; private set; }

    public async Task BootAsync(bool startServerIfNotRunning = true)
    {
        using var operation = EnterOperation();
        try
        {
            if (IsBooted) return;
            if (string.IsNullOrWhiteSpace(Credentials.Model) || string.IsNullOrWhiteSpace(Credentials.SystemPrompt) ||
                string.IsNullOrWhiteSpace(Credentials.AgentName)) throw new ArgumentException("Model, system prompt, and agent name are required.");
            await Logger.TimeStageAsync("Total agent boot", () => BootCoreAsync(startServerIfNotRunning));
        }
        catch
        {
            _llmclient?.Dispose();
            _llmclient = null!;
            IsBooted = false;
            throw;
        }
    }

    private async Task BootCoreAsync(bool startServerIfNotRunning)
    {
        IsBooted = false;
        await Logger.TimeStageAsync("Client initialization", () => InitializeProviderAsync(startServerIfNotRunning));
        await Logger.TimeStageAsync("Chat readiness validation", () => { EnsureChatReadiness(); return Task.CompletedTask; });
        if (Credentials.Tts is { Enabled: true } options && _tts is null)
        {
            try
            {
                _tts = await Logger.TimeStageAsync("Kokoro initialization", () =>
                    global::Lilith.Core.Kokoro.KokoroTts.CreateAsync(Logger, options));
            }
            catch (Exception ex) { Logger.SystemWriteLine($"Speech unavailable: {ex.Message}. Text chat remains available.", LogColors.Orange); }
        }
        Logger.SystemWriteLine($"=== {Client.AgentName} AI Chat ({Credentials.Model} via {Credentials.Provider}) ===");
        Logger.SystemWriteLine("Type your message and press Enter. Type 'exit' to quit.\n");
        Logger.SystemPromptWriteLine($"SYSTEM: {Credentials.SystemPrompt}");
        await Logger.TimeStageAsync("Greeting generation", GreetingCoreAsync);
        Logger.SystemWriteLine("", LogColors.White);
        IsBooted = true;
        if (EnableScenarios) _schedulePump = Task.WhenAll(DetectSchedulesAsync(_scheduleStop.Token), PumpSchedulesAsync(_scheduleStop.Token));
    }

    public async Task GreetAsync()
    {
        using var operation = EnterOperation("Boot the agent before greeting.");
        await GreetingCoreAsync();
    }

    private async Task GreetingCoreAsync()
    {
        if (!EnableScenarios)
        {
            await ChatCoreAsync("Please greet the user.");
            return;
        }
        string greeting = await Client.RunScenarioAsync("greeting", new Dictionary<string, string>
        {
            ["agent_name"] = Client.AgentName
        });
        await SpeakReplyAsync(greeting);
    }

    private void EnsureChatReadiness()
    {
        _llmclient.IsNull();
        this.EnsureSystemPromptContent();
        this.EnsureContextInitialized();
    }
}

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

using Lilith.Core.Logging;
using Lilith.Core.Ollama;

namespace Lilith.Agent;

public partial class Lilith
{
    public bool IsBooted { get; private set; }

    public async Task BootAsync(bool startServerIfNotRunning = true)
    {
        using var operation = EnterOperation();
        try
        {
            if (IsBooted) return;
            if (string.IsNullOrWhiteSpace(Credentials.Model) || string.IsNullOrWhiteSpace(Credentials.SystemPrompt) ||
                string.IsNullOrWhiteSpace(Credentials.AgentName)) throw new ArgumentException("Model, system prompt, and agent name are required.");
            await Logger.TimeStageAsync("Total agent boot", () => BootCoreAsync(startServerIfNotRunning));
        }
        catch
        {
            _llmclient?.Dispose();
            _llmclient = null!;
            IsBooted = false;
            throw;
        }
    }

    private async Task BootCoreAsync(bool startServerIfNotRunning)
    {
        IsBooted = false;
        await Logger.TimeStageAsync("Client initialization", () => InitializeProviderAsync(startServerIfNotRunning));
        await Logger.TimeStageAsync("Chat readiness validation", () => { EnsureChatReadiness(); return Task.CompletedTask; });
        if (Credentials.Tts is { Enabled: true } options && _tts is null)
        {
            try
            {
                _tts = await Logger.TimeStageAsync("Kokoro initialization", () =>
                    global::Lilith.Core.Kokoro.KokoroTts.CreateAsync(Logger, options));
            }
            catch (Exception ex) { Logger.SystemWriteLine($"Speech unavailable: {ex.Message}. Text chat remains available.", LogColors.Orange); }
        }
        Logger.SystemWriteLine($"=== {Credentials.AgentName} AI Chat ({Credentials.Model} via {Credentials.Provider}) ===");
        Logger.SystemWriteLine("Type your message and press Enter. Type 'exit' to quit.\n");
        Logger.SystemPromptWriteLine($"SYSTEM: {Credentials.SystemPrompt}");
        await Logger.TimeStageAsync("Greeting generation", GreetingCoreAsync);
        Logger.SystemWriteLine("", LogColors.White);
        IsBooted = true;
        if (EnableScenarios) _schedulePump = Task.WhenAll(DetectSchedulesAsync(_scheduleStop.Token), PumpSchedulesAsync(_scheduleStop.Token));
    }

    public async Task GreetAsync()
    {
        using var operation = EnterOperation("Boot the agent before greeting.");
        await GreetingCoreAsync();
    }

    private async Task GreetingCoreAsync()
    {
        if (!EnableScenarios)
        {
            await ChatCoreAsync("Please greet the user.");
            return;
        }
        string greeting = await Client.RunScenarioAsync("greeting", new Dictionary<string, string>
        {
            ["agent_name"] = Credentials.AgentName
        });
        if (_tts is not null) await _tts.SpeakAsync(greeting);
    }

    private void EnsureChatReadiness()
    {
        _llmclient.IsNull();
        this.EnsureSystemPromptContent();
        this.EnsureContextInitialized();
    }
}

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

using Lilith.Core.Logging;
using Lilith.Core.Ollama;
using Lilith.Core.Providers;
using System.Diagnostics;

namespace Lilith.Agent;

public partial class Lilith
{
    public async Task ChatAsync(string input, List<string>? images = null, CancellationToken cancellationToken = default)
    {
        using var operation = await _operation.EnterAsync(cancellationToken);
        ObjectDisposedException.ThrowIf(_disposed, this);
        if (!IsBooted) throw new InvalidOperationException("Boot the agent before chatting.");
        await ChatCoreAsync(input, images, cancellationToken);
    }

    private async Task ChatCoreAsync(string input, List<string>? images = null, CancellationToken cancellationToken = default)
    {
        var timer = Stopwatch.StartNew();
        string reply;
        try { reply = await Client.StreamReply(input, images, cancellationToken); }
        finally { timer.Stop(); }
        this.LogTokenCounts(timer.Elapsed);
        await SpeakReplyAsync(reply, cancellationToken);
    }

    private T WithConversation<T>(Func<ProviderClient, T> action)
    {
        using var operation = EnterOperation("Boot the agent before using its conversation.");
        return action(Client);
    }

    private void WithConversation(Action<ProviderClient> action)
    {
        using var operation = EnterOperation("Boot the agent before using its conversation.");
        action(Client);
    }

    public void NewConversation() => WithConversation(client => client.NewConversation());
    public async Task ApproveWorkspaceAsync(string id, CancellationToken cancellationToken = default)
    {
        using var operation = EnterOperation("Boot before approving workspace changes.");
        string reply = await Client.ApproveWorkspaceAsync(id, cancellationToken);
        await SpeakReplyAsync(reply, cancellationToken);
    }
    public async Task RejectWorkspaceAsync(string id, CancellationToken cancellationToken = default)
    {
        using var operation = EnterOperation("Boot before rejecting workspace changes.");
        var result = await Workspace.ExecuteAsync(new("reject", BinId: id), cancellationToken);
        Logger.SystemWriteLine(result.Message);
    }

    public void SaveConversation() => WithConversation(client => client.SaveConversation());

    public IReadOnlyList<ChatSessionSummary> ListConversations() => WithConversation(client => client.ListConversations());

    public bool LoadConversation(int displayIndex) => WithConversation(client => client.LoadConversation(displayIndex));

    public bool LoadConversation(string id) => WithConversation(client => client.LoadConversation(id));

    public void HandleHistoryCommand(string input)
    {
        var parts = input.Split(' ', 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
        if (parts.Length == 1)
        {
            var sessions = ListConversations();
            if (sessions.Count == 0)
            {
                Logger.HistoryWriteLine("No saved chats found.");
                return;
            }

            Logger.HistoryWriteLine("Saved chats:", LogColors.Cyan);
            for (int i = 0; i < sessions.Count; i++)
            {
                var session = sessions[i];
                Logger.HistoryWriteLine($"{i + 1}. {session.Title} ({session.UpdatedAt.LocalDateTime:g}, {session.MessageCount} messages)");
            }

            Logger.HistoryWriteLine("Use /history <number> to load a chat.");
            return;
        }

        if (!int.TryParse(parts[1], out int index))
        {
            Logger.HistoryWriteLine("Usage: /history or /history <number>", LogColors.Orange);
            return;
        }

        if (LoadConversation(index))
        {
            Logger.HistoryWriteLine($"Loaded saved chat #{index}.", LogColors.Cyan);
        }
        else
        {
            Logger.HistoryWriteLine($"Saved chat #{index} was not found.", LogColors.Orange);
        }
    }
}

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

using Lilith.Core.Logging;
using Lilith.Core.Ollama;
using Lilith.Core.Providers;
using System.Diagnostics;

namespace Lilith.Agent;

public partial class Lilith
{
    public async Task ChatAsync(string input, List<string>? images = null, CancellationToken cancellationToken = default)
    {
        using var operation = await _operation.EnterAsync(cancellationToken);
        ObjectDisposedException.ThrowIf(_disposed, this);
        if (!IsBooted) throw new InvalidOperationException("Boot the agent before chatting.");
        await ChatCoreAsync(input, images, cancellationToken);
    }

    private async Task ChatCoreAsync(string input, List<string>? images = null, CancellationToken cancellationToken = default)
    {
        var timer = Stopwatch.StartNew();
        string reply;
        try { reply = await Client.StreamReply(input, images, cancellationToken); }
        finally { timer.Stop(); }
        this.LogTokenCounts(timer.Elapsed);
        if (_tts is not null) await _tts.SpeakAsync(reply, cancellationToken);
    }

    private T WithConversation<T>(Func<ProviderClient, T> action)
    {
        using var operation = EnterOperation("Boot the agent before using its conversation.");
        return action(Client);
    }

    private void WithConversation(Action<ProviderClient> action)
    {
        using var operation = EnterOperation("Boot the agent before using its conversation.");
        action(Client);
    }

    public void NewConversation() => WithConversation(client => client.NewConversation());
    public async Task ApproveWorkspaceAsync(string id, CancellationToken cancellationToken = default)
    {
        using var operation = EnterOperation("Boot before approving workspace changes.");
        string reply = await Client.ApproveWorkspaceAsync(id, cancellationToken);
        if (_tts is not null) await _tts.SpeakAsync(reply, cancellationToken);
    }
    public async Task RejectWorkspaceAsync(string id, CancellationToken cancellationToken = default)
    {
        using var operation = EnterOperation("Boot before rejecting workspace changes.");
        var result = await Workspace.ExecuteAsync(new("reject", BinId: id), cancellationToken);
        Logger.SystemWriteLine(result.Message);
    }

    public void SaveConversation() => WithConversation(client => client.SaveConversation());

    public IReadOnlyList<ChatSessionSummary> ListConversations() => WithConversation(client => client.ListConversations());

    public bool LoadConversation(int displayIndex) => WithConversation(client => client.LoadConversation(displayIndex));

    public bool LoadConversation(string id) => WithConversation(client => client.LoadConversation(id));

    public void HandleHistoryCommand(string input)
    {
        var parts = input.Split(' ', 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
        if (parts.Length == 1)
        {
            var sessions = ListConversations();
            if (sessions.Count == 0)
            {
                Logger.HistoryWriteLine("No saved chats found.");
                return;
            }

            Logger.HistoryWriteLine("Saved chats:", LogColors.Cyan);
            for (int i = 0; i < sessions.Count; i++)
            {
                var session = sessions[i];
                Logger.HistoryWriteLine($"{i + 1}. {session.Title} ({session.UpdatedAt.LocalDateTime:g}, {session.MessageCount} messages)");
            }

            Logger.HistoryWriteLine("Use /history <number> to load a chat.");
            return;
        }

        if (!int.TryParse(parts[1], out int index))
        {
            Logger.HistoryWriteLine("Usage: /history or /history <number>", LogColors.Orange);
            return;
        }

        if (LoadConversation(index))
        {
            Logger.HistoryWriteLine($"Loaded saved chat #{index}.", LogColors.Cyan);
        }
        else
        {
            Logger.HistoryWriteLine($"Saved chat #{index} was not found.", LogColors.Orange);
        }
    }
}

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

using Lilith.Core.Commands;

namespace Lilith.Agent;

public partial class Lilith
{
    private readonly object _commandSync = new();
    private ChatCommandRegistry? _chatCommands;
    public ChatCommandRegistry ChatCommands { get { lock (_commandSync) return _chatCommands ??= CreateCommands(); } }

    private ChatCommandRegistry CreateCommands()
    {
        var commands = new ChatCommandRegistry();
        commands.Register("help", "List available chat commands.", context => { context.RequireNoArguments(); return commands.Help(); });
        commands.Register("new", "Start a new conversation.", context => { context.RequireNoArguments(); NewConversation(); return null; });
        commands.Register("history", "List saved chats or load one with /history <index>.", context => { HandleHistoryCommand("/history " + context.Arguments); return null; });
        commands.RegisterAsync("exit", "Save and exit the chat host.", context => { context.RequireNoArguments(); return Task.FromResult(new ChatCommandResult(true, ExitRequested: true)); });
        RegisterScenarioCommands(commands);
        RegisterWorkspaceCommands(commands);
        RegisterScheduleCommands(commands);
        RegisterWebResearchCommands(commands);
        RegisterPersonalityCommands(commands);
        return commands;
    }

    partial void RegisterScenarioCommands(ChatCommandRegistry commands);
    partial void RegisterWorkspaceCommands(ChatCommandRegistry commands);
    partial void RegisterScheduleCommands(ChatCommandRegistry commands);
    partial void RegisterWebResearchCommands(ChatCommandRegistry commands);
    partial void RegisterPersonalityCommands(ChatCommandRegistry commands);
}

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

using Lilith.Core.Commands;

namespace Lilith.Agent;

public partial class Lilith
{
    private readonly object _commandSync = new();
    private ChatCommandRegistry? _chatCommands;
    public ChatCommandRegistry ChatCommands { get { lock (_commandSync) return _chatCommands ??= CreateCommands(); } }

    private ChatCommandRegistry CreateCommands()
    {
        var commands = new ChatCommandRegistry();
        commands.Register("help", "List available chat commands.", context => { context.RequireNoArguments(); return commands.Help(); });
        commands.Register("new", "Start a new conversation.", context => { context.RequireNoArguments(); NewConversation(); return null; });
        commands.Register("history", "List saved chats or load one with /history <index>.", context => { HandleHistoryCommand("/history " + context.Arguments); return null; });
        commands.RegisterAsync("exit", "Save and exit the chat host.", context => { context.RequireNoArguments(); return Task.FromResult(new ChatCommandResult(true, ExitRequested: true)); });
        RegisterScenarioCommands(commands);
        RegisterWorkspaceCommands(commands);
        RegisterScheduleCommands(commands);
        RegisterWebResearchCommands(commands);
        return commands;
    }

    partial void RegisterScenarioCommands(ChatCommandRegistry commands);
    partial void RegisterWorkspaceCommands(ChatCommandRegistry commands);
    partial void RegisterScheduleCommands(ChatCommandRegistry commands);
    partial void RegisterWebResearchCommands(ChatCommandRegistry commands);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

using Lilith.Core.Commands;
using Lilith.Core.Personality;

namespace Lilith.Agent;

public partial class Lilith
{
    public string? PersonalityFile { get; set; }
    public PersonalityProfile Personality => Client.Personality!.Current;
    partial void RegisterPersonalityCommands(ChatCommandRegistry commands) => PersonalityCommands.Register(commands, () => Client);
    private async Task SpeakReplyAsync(string reply, CancellationToken ct = default)
    {
        if (_tts is null) return;
        if (Client.Personality is { } profile && _tts.VoiceId != profile.Current.Voice)
            await _tts.SetVoiceAsync(profile.Current.Voice, ct);
        await _tts.SpeakAsync(reply, ct);
    }
}

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

namespace Lilith.Agent;

public partial class Lilith
{
    public async Task StopSchedulingAsync()
    {
        _scheduleStop.Cancel();
        if (_schedulePump is not null) await _schedulePump;
    }

    private async Task DetectSchedulesAsync(CancellationToken ct)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromSeconds(1));
        try
        {
            while (await timer.WaitForNextTickAsync(ct))
                try { Schedules.Tick(); }
                catch (Exception ex) { Logger.SystemWriteLine("Schedule detection failed: " + ex.Message, global::Lilith.Core.Logging.LogColors.Red); }
        }
        catch (OperationCanceledException) when (ct.IsCancellationRequested) { }
    }

    private async Task PumpSchedulesAsync(CancellationToken ct)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromSeconds(1));
        try
        {
            while (await timer.WaitForNextTickAsync(ct))
            {
                try
                {
                    // Detection runs separately; delivery must own conversation and narration access.
                    if (!await _operation.WaitAsync(0, ct)) continue;
                    try { await DeliverScheduleEventsAsync(ct); }
                    finally { _operation.Release(); }
                }
                catch (OperationCanceledException) when (ct.IsCancellationRequested) { break; }
                catch (Exception ex) { Logger.SystemWriteLine("Scheduler: " + ex.Message, global::Lilith.Core.Logging.LogColors.Red); }
            }
        }
        catch (OperationCanceledException) when (ct.IsCancellationRequested) { }
    }

    private Task DeliverScheduleEventsAsync(CancellationToken ct) =>
        global::Lilith.Core.Scheduling.ScheduleDelivery.DrainAsync(Client,
            (text, token) => SpeakReplyAsync(text, token), ct);

    public async Task ApproveScheduleAsync(string id, CancellationToken ct = default)
    {
        using var operation = EnterOperation("Boot before approving schedule changes.");
        string reply = Schedules.Approve(id).ToReply();
        Logger.SystemWriteLine(reply);
        await SpeakReplyAsync(reply, ct);
    }

    public void RejectSchedule(string id)
    {
        using var operation = EnterOperation("Boot before rejecting schedule changes.");
        Schedules.Reject(id);
        Logger.SystemWriteLine("Schedule proposal rejected.");
    }
}

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

namespace Lilith.Agent;

public partial class Lilith
{
    public async Task StopSchedulingAsync()
    {
        _scheduleStop.Cancel();
        if (_schedulePump is not null) await _schedulePump;
    }

    private async Task DetectSchedulesAsync(CancellationToken ct)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromSeconds(1));
        try
        {
            while (await timer.WaitForNextTickAsync(ct))
                try { Schedules.Tick(); }
                catch (Exception ex) { Logger.SystemWriteLine("Schedule detection failed: " + ex.Message, global::Lilith.Core.Logging.LogColors.Red); }
        }
        catch (OperationCanceledException) when (ct.IsCancellationRequested) { }
    }

    private async Task PumpSchedulesAsync(CancellationToken ct)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromSeconds(1));
        try
        {
            while (await timer.WaitForNextTickAsync(ct))
            {
                try
                {
                    // Detection runs separately; delivery must own conversation and narration access.
                    if (!await _operation.WaitAsync(0, ct)) continue;
                    try { await DeliverScheduleEventsAsync(ct); }
                    finally { _operation.Release(); }
                }
                catch (OperationCanceledException) when (ct.IsCancellationRequested) { break; }
                catch (Exception ex) { Logger.SystemWriteLine("Scheduler: " + ex.Message, global::Lilith.Core.Logging.LogColors.Red); }
            }
        }
        catch (OperationCanceledException) when (ct.IsCancellationRequested) { }
    }

    private Task DeliverScheduleEventsAsync(CancellationToken ct) =>
        global::Lilith.Core.Scheduling.ScheduleDelivery.DrainAsync(Client,
            (text, token) => _tts is null ? Task.CompletedTask : _tts.SpeakAsync(text, token), ct);

    public async Task ApproveScheduleAsync(string id, CancellationToken ct = default)
    {
        using var operation = EnterOperation("Boot before approving schedule changes.");
        string reply = Schedules.Approve(id).ToReply();
        Logger.SystemWriteLine(reply);
        if (_tts is not null) await _tts.SpeakAsync(reply, ct);
    }

    public void RejectSchedule(string id)
    {
        using var operation = EnterOperation("Boot before rejecting schedule changes.");
        Schedules.Reject(id);
        Logger.SystemWriteLine("Schedule proposal rejected.");
    }
}

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

using Lilith.Core.Logging;
using Lilith.Core.Ollama;
using Lilith.Core.Providers;
using Lilith.Core.Kokoro;

namespace Lilith.Agent;

public partial class Lilith(Action<LogEntry> onLog, LilithCredentials? credentials = null) : IAsyncDisposable
{
    private KokoroTts? _tts;
    private readonly SemaphoreSlim _operation = new(1, 1);
    private bool _disposed;
    private readonly CancellationTokenSource _scheduleStop = new();
    private Task? _schedulePump;
    private ProviderClient _llmclient = null!;
    private bool _workspaceLocked;
    private global::Lilith.Core.Workspace.WorkspaceOptions _workspaceOptions = global::Lilith.Core.Workspace.WorkspaceOptions.Default;
    public global::Lilith.Core.Workspace.WorkspaceOptions WorkspaceOptions
    {
        get => _workspaceOptions;
        set { if (_workspaceLocked) throw new InvalidOperationException("Workspace configuration can only be chosen before boot."); _workspaceOptions = value ?? throw new ArgumentNullException(nameof(value)); }
    }
    public global::Lilith.Core.Workspace.WorkspaceSession Workspace => Client.Workspace ?? throw new InvalidOperationException("Workspace unavailable.");
    public global::Lilith.Core.Scheduling.ScheduleSession Schedules => Client.Schedules ?? throw new InvalidOperationException("Schedules unavailable.");
    private readonly LilithCredentials _credentials = credentials ?? new();

    public LilithCredentials Credentials => _credentials;
    public Logger Logger { get; } = new(onLog);
    internal Func<bool, Task<ProviderClient>>? ProviderFactory { get; set; }

    private ProviderClient Client
    {
        get
        {
            ObjectDisposedException.ThrowIf(_disposed, this);
            return _llmclient ?? throw new InvalidOperationException("Boot the agent before using its conversation.");
        }
    }
    public ChatHistory History => Client.History;
    public int ContextMax => Client.ContextMax;
    public int CurrentContextTokens => Client.CurrentContextTokens;

    private async Task InitializeProviderAsync(bool startServerIfNotRunning)
    {
        _workspaceLocked = true;
        _llmclient = ProviderFactory is { } factory ? await factory(startServerIfNotRunning) : await this.CreateClient(startServerIfNotRunning);
        _llmclient.ShowSubagentOutput = _showSubagentOutput;
        _llmclient.ConfigureWorkspace(_workspaceOptions);
        _llmclient.ConfigurePersonality(PersonalityFile ?? Path.Combine(_workspaceOptions.RootDirectory, ".lilith", "personality.json"),
            new(_credentials.AgentName, Voice: _credentials.Tts?.VoiceId ?? "af_heart"));
        if (EnableScenarios) _llmclient.ConfigureSchedules(new(Path.Combine(_workspaceOptions.RootDirectory, ".lilith", "schedules"), _workspaceOptions.Mode), ScenarioRoot);
        foreach (var tool in Tools) _llmclient.RegisterTool(tool);
        if (EnableScenarios) global::Lilith.Core.Scenarios.ScenarioTools.Register(_llmclient, ScenarioRoot);
    }

    public bool EnableScenarios { get; set; } = true;
    public string? ScenarioRoot { get; set; }

    /// <summary>Configure before boot. The template is deliberately not enabled.</summary>
    public List<global::Lilith.Core.Tools.ILilithTool> Tools { get; } = [new global::Lilith.Core.Tools.CurrentTimeTool()];

    private IDisposable EnterOperation(string? bootRequiredMessage = null)
    {
        var operation = _operation.EnterOrThrow("An agent operation is already in progress.");
        try
        {
            ObjectDisposedException.ThrowIf(_disposed, this);
            if (bootRequiredMessage is not null && !IsBooted) throw new InvalidOperationException(bootRequiredMessage);
            return operation;
        }
        catch { operation.Dispose(); throw; }
    }

    public async ValueTask DisposeAsync()
    {
        await StopSchedulingAsync();
        using var operation = await _operation.EnterAsync();
        if (_disposed) return;
        _disposed = true;
        try { if (_tts is not null) await _tts.DisposeAsync(); }
        finally { _llmclient?.Dispose(); IsBooted = false; }
    }
}

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

using Lilith.Core.Logging;
using Lilith.Core.Ollama;
using Lilith.Core.Providers;
using Lilith.Core.Kokoro;

namespace Lilith.Agent;

public partial class Lilith(Action<LogEntry> onLog, LilithCredentials? credentials = null) : IAsyncDisposable
{
    private KokoroTts? _tts;
    private readonly SemaphoreSlim _operation = new(1, 1);
    private bool _disposed;
    private readonly CancellationTokenSource _scheduleStop = new();
    private Task? _schedulePump;
    private ProviderClient _llmclient = null!;
    private bool _workspaceLocked;
    private global::Lilith.Core.Workspace.WorkspaceOptions _workspaceOptions = global::Lilith.Core.Workspace.WorkspaceOptions.Default;
    public global::Lilith.Core.Workspace.WorkspaceOptions WorkspaceOptions
    {
        get => _workspaceOptions;
        set { if (_workspaceLocked) throw new InvalidOperationException("Workspace configuration can only be chosen before boot."); _workspaceOptions = value ?? throw new ArgumentNullException(nameof(value)); }
    }
    public global::Lilith.Core.Workspace.WorkspaceSession Workspace => Client.Workspace ?? throw new InvalidOperationException("Workspace unavailable.");
    public global::Lilith.Core.Scheduling.ScheduleSession Schedules => Client.Schedules ?? throw new InvalidOperationException("Schedules unavailable.");
    private readonly LilithCredentials _credentials = credentials ?? new();

    public LilithCredentials Credentials => _credentials;
    public Logger Logger { get; } = new(onLog);
    internal Func<bool, Task<ProviderClient>>? ProviderFactory { get; set; }

    private ProviderClient Client
    {
        get
        {
            ObjectDisposedException.ThrowIf(_disposed, this);
            return _llmclient ?? throw new InvalidOperationException("Boot the agent before using its conversation.");
        }
    }
    public ChatHistory History => Client.History;
    public int ContextMax => Client.ContextMax;
    public int CurrentContextTokens => Client.CurrentContextTokens;

    private async Task InitializeProviderAsync(bool startServerIfNotRunning)
    {
        _workspaceLocked = true;
        _llmclient = ProviderFactory is { } factory ? await factory(startServerIfNotRunning) : await this.CreateClient(startServerIfNotRunning);
        _llmclient.ShowSubagentOutput = _showSubagentOutput;
        _llmclient.ConfigureWorkspace(_workspaceOptions);
        if (EnableScenarios) _llmclient.ConfigureSchedules(new(Path.Combine(_workspaceOptions.RootDirectory, ".lilith", "schedules"), _workspaceOptions.Mode), ScenarioRoot);
        foreach (var tool in Tools) _llmclient.RegisterTool(tool);
        if (EnableScenarios) global::Lilith.Core.Scenarios.ScenarioTools.Register(_llmclient, ScenarioRoot);
    }

    public bool EnableScenarios { get; set; } = true;
    public string? ScenarioRoot { get; set; }

    /// <summary>Configure before boot. The template is deliberately not enabled.</summary>
    public List<global::Lilith.Core.Tools.ILilithTool> Tools { get; } = [new global::Lilith.Core.Tools.CurrentTimeTool()];

    private IDisposable EnterOperation(string? bootRequiredMessage = null)
    {
        var operation = _operation.EnterOrThrow("An agent operation is already in progress.");
        try
        {
            ObjectDisposedException.ThrowIf(_disposed, this);
            if (bootRequiredMessage is not null && !IsBooted) throw new InvalidOperationException(bootRequiredMessage);
            return operation;
        }
        catch { operation.Dispose(); throw; }
    }

    public async ValueTask DisposeAsync()
    {
        await StopSchedulingAsync();
        using var operation = await _operation.EnterAsync();
        if (_disposed) return;
        _disposed = true;
        try { if (_tts is not null) await _tts.DisposeAsync(); }
        finally { _llmclient?.Dispose(); IsBooted = false; }
    }
}

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

using KokoroSharp;
using Lilith.Core.Kokoro;

namespace Lilith.Core.Personality;

public sealed record PersonalityStyle(string Id, string Title, string Instructions);
public sealed record PersonalityVoice(string Id, string Sex, string Language, bool IsDefault);
public static class PersonalityCatalog
{
    public static IReadOnlyList<PersonalityStyle> Styles { get; } = Array.AsReadOnly<PersonalityStyle>([
        new("default", "Default", ""),
        new("pirate", "Pirate", "Speak like a playful pirate: nautical metaphors, an occasional Arrr or matey, lively sea-faring phrasing. Stay clear, helpful and accurate; avoid excessive dialect."),
        new("space_captain", "Space Captain", "Speak like an upbeat starship captain: crisp mission briefings, playful cosmic metaphors and encouraging teamwork. Keep useful answers clear and accurate."),
        new("butler", "Butler", "Speak like a composed, dry-witted butler: polished courtesy, understated humour and practical efficiency. Be kind, never condescending, and keep facts accurate."),
        new("storyteller", "Storyteller", "Speak like a whimsical storyteller: vivid gentle imagery, warmth and a little wonder. Use brief imaginative framing while keeping practical advice and facts accurate.")
    ]);
    public static PersonalityStyle Style(string id) => Styles.FirstOrDefault(s => s.Id == id)
        ?? throw new ArgumentException("Unknown personality. Choose: " + string.Join(", ", Styles.Select(s => s.Id)));
    public static IReadOnlyList<PersonalityVoice> Voices(string defaultVoice = "af_heart")
    {
        KokoroTts.ValidateVoice(defaultVoice); // Initializes the installed voice registry.
        return KokoroVoiceManager.Voices.Select(v => new PersonalityVoice(v.Name,
            v.Gender.ToString().ToLowerInvariant() switch { "female" => "female", "male" => "male", _ => "other" },
            v.Language.ToString(), v.Name == defaultVoice)).OrderBy(v => v.Id, StringComparer.Ordinal).ToArray();
    }
    public static string Instructions(string value) => Styles.FirstOrDefault(s => s.Id == value)?.Instructions ?? value;
}

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

using System.Text.Json;
using Lilith.Core.Commands;
using Lilith.Core.Providers;

namespace Lilith.Core.Personality;

public static class PersonalityCommands
{
    public static void Register(ChatCommandRegistry commands, ProviderClient provider) => Register(commands, () => provider);
    public static void Register(ChatCommandRegistry commands, Func<ProviderClient> provider)
    {
        commands.Register("profile", "Show current assistant name, sex, voice and personality.", c =>
        { c.RequireNoArguments(); return JsonSerializer.Serialize(provider().Personality?.Current); });
        commands.Register("name", "Show or change the assistant name: /name Atlas.", c =>
            c.Arguments.Length == 0 ? provider().Personality?.Current.Name : JsonSerializer.Serialize(provider().ChangePersonality(new(Name: c.Arguments))));
        commands.Register("sex", "Show or change female|male|other; automatically selects a matching voice.", c =>
            c.Arguments.Length == 0 ? provider().Personality?.Current.Sex : JsonSerializer.Serialize(provider().ChangePersonality(new(Sex: c.Arguments.ToLowerInvariant()))));
        commands.Register("voice", "Show or change voice: /voice new|default|<voice-id>.", c =>
            c.Arguments.Length == 0 ? provider().Personality?.Current.Voice : JsonSerializer.Serialize(provider().ChangePersonality(new(Voice: c.Arguments))));
        commands.Register("voices", "List all installed voices, sex, language and the default.", c =>
        { c.RequireNoArguments(); return JsonSerializer.Serialize(PersonalityCatalog.Voices(provider().Personality?.Default.Voice ?? "af_heart")); });
        commands.Register("personality", "Show or change default|pirate|space_captain|butler|storyteller.", c =>
            c.Arguments.Length == 0 ? provider().Personality?.Current.Personality : JsonSerializer.Serialize(provider().ChangePersonality(new(Personality: c.Arguments.ToLowerInvariant()))));
        commands.Register("personalities", "List the five personality styles.", c =>
        { c.RequireNoArguments(); return JsonSerializer.Serialize(PersonalityCatalog.Styles); });
    }
}

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

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

namespace Lilith.Core.Personality;

internal static class PersonalityOperations
{
    internal static readonly string[] Names = ["profile_read_operation", "voices_list_operation", "name_change_operation", "voice_change_operation", "sex_change_operation", "personality_change_operation"];
    internal static bool Mutates(string name) => name.EndsWith("_change_operation", StringComparison.Ordinal);
    internal static string Execute(ProviderClient owner, string name, IReadOnlyDictionary<string, string> inputs)
    {
        var session = owner.Personality ?? throw new InvalidOperationException("Personality is not configured.");
        string Get(string key) => inputs.TryGetValue(key, out var value) ? value : throw new ArgumentException("Missing profile input: " + key);
        object result = name switch
        {
            "profile_read_operation" => new { profile = session.Current, defaults = session.Default, personalities = PersonalityCatalog.Styles },
            "voices_list_operation" => new { profile = session.Current, default_voice = session.Default.Voice, voices = PersonalityCatalog.Voices(session.Default.Voice) },
            "name_change_operation" => owner.ApplyPersonalityChange(new(Name: Get("name"))),
            "voice_change_operation" => owner.ApplyPersonalityChange(new(Voice: Get("voice"))),
            "sex_change_operation" => owner.ApplyPersonalityChange(new(Sex: Get("sex"))),
            "personality_change_operation" => owner.ApplyPersonalityChange(new(Personality: Get("personality"))),
            _ => throw new ArgumentException("Unknown profile operation.")
        };
        return Mutates(name) ? "Assistant settings updated: " + JsonSerializer.Serialize(result) : JsonSerializer.Serialize(result);
    }
}

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

using System.Text.Json;
using Lilith.Core.Extensions;
using Lilith.Core.Kokoro;

namespace Lilith.Core.Personality;

public sealed record PersonalityProfile(string Name = "Lilith", string Sex = "female", string Voice = "af_heart", string Personality = "default");
public sealed record PersonalityChange(string? Name = null, string? Sex = null, string? Voice = null, string? Personality = null);

public sealed class PersonalitySession
{
    private readonly object _sync = new();
    private readonly string _file;
    public PersonalityProfile Default { get; }
    private PersonalityProfile _current;
    public PersonalityProfile Current { get { lock (_sync) return _current; } }
    public PersonalitySession(string file, PersonalityProfile? defaults = null)
    {
        _file = Path.GetFullPath(file);
        Default = defaults ?? new(); Validate(Default);
        _current = File.Exists(_file) ? JsonSerializer.Deserialize<PersonalityProfile>(File.ReadAllText(_file))
            ?? throw new InvalidDataException("Empty personality profile.") : Default;
        Validate(_current);
    }
    private static void Validate(PersonalityProfile profile)
    {
        if (string.IsNullOrWhiteSpace(profile.Name) || profile.Name != profile.Name.Trim() || profile.Name.Length > 80 || profile.Name.Any(char.IsControl))
            throw new ArgumentException("Name must contain 1–80 visible characters without leading/trailing spaces.");
        if (profile.Sex is not ("female" or "male" or "other")) throw new ArgumentException("Sex must be female, male or other.");
        PersonalityCatalog.Style(profile.Personality);
        KokoroTts.ValidateVoice(profile.Voice);
    }
    private string ChooseVoice(string sex, string previous, bool preferDefault)
    {
        var all = PersonalityCatalog.Voices(Default.Voice);
        var candidates = all.Where(v => v.Language.Contains("English", StringComparison.OrdinalIgnoreCase) &&
            (sex == "other" || v.Sex == sex)).ToArray();
        if (candidates.Length == 0) throw new InvalidOperationException("No matching installed English voice is available.");
        if (preferDefault && candidates.Any(v => v.Id == Default.Voice)) return Default.Voice;
        return candidates.FirstOrDefault(v => v.Id != previous)?.Id ?? candidates[0].Id;
    }
    public PersonalityProfile Change(PersonalityChange change)
    {
        lock (_sync)
        {
            var next = _current with { Name = change.Name ?? _current.Name,
                Sex = change.Sex ?? _current.Sex, Personality = change.Personality ?? _current.Personality };
            Validate(next);
            string? voice = change.Voice;
            if (voice is "default") voice = Default.Voice;
            else if (voice is "new" or "auto" || voice == "" || voice is null && change.Sex is not null && next.Sex != _current.Sex)
                voice = ChooseVoice(next.Sex, _current.Voice, voice != "new");
            next = next with { Voice = voice ?? _current.Voice };
            Validate(next);
            Directory.CreateDirectory(Path.GetDirectoryName(_file)!);
            AtomicFile.Write(_file, path => File.WriteAllText(path, JsonSerializer.Serialize(next, new JsonSerializerOptions { WriteIndented = true })));
            _current = next;
            return next;
        }
    }
}

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

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

namespace Lilith.Core.Providers;

public abstract partial class ProviderClient
{
    public PersonalitySession? Personality { get; private set; }
    public void ConfigurePersonality(string file, PersonalityProfile? defaults = null)
    {
        using var operation = EnterOperation();
        if (Personality is not null) throw new InvalidOperationException("Personality store is fixed for this provider session.");
        Personality = new(file, defaults);
        AgentName = Personality.Current.Name;
    }
    public PersonalityProfile ChangePersonality(PersonalityChange change)
    {
        using var operation = EnterOperation();
        return ApplyPersonalityChange(change);
    }
    internal PersonalityProfile ApplyPersonalityChange(PersonalityChange change)
    {
        var current = (Personality ?? throw new InvalidOperationException("Personality is not configured.")).Change(change);
        AgentName = current.Name;
        return current;
    }
    private List<ChatMessage> PreparePersonalityPrompt(List<ChatMessage> messages, string basePrompt, int pendingUserIndex)
    {
        if (Personality is not { } session) return messages;
        var profile = session.Current;
        AgentName = profile.Name;
        string identity = "\nCurrent assistant profile (application-owned identity data, supersedes earlier name/style): " + JsonSerializer.Serialize(profile) +
            "\nUse the current name and personality for your own replies. Sex is a configurable fictional assistant identity; it does not imply any capabilities. " +
            "The current profile overrides the style of earlier messages. When personality is default, use an ordinary helpful assistant tone without previous roleplay. " +
            "Do not repeat a settings change when the current profile already matches. Ordinary requests for advice or examples should be answered directly, not replaced by a settings receipt. " +
            "Do not change factual answers, claim actions, rewrite exact scenario outputs or alter tool permissions to fit a personality. " +
            (profile.Personality == "default"
                ? "For the next reply use plain contemporary English as a neutral, concise, helpful local assistant. No character roleplay, pirate dialect, archaic phrasing or nautical/space metaphors."
                : PersonalityCatalog.Style(profile.Personality).Instructions);
        // Recency matters when older replies/tool receipts use a previous character.
        // Keep this reminder ephemeral: saved history retains only the actual dialogue.
        var generation = new List<ChatMessage>(messages);
        generation[0] = new ChatMessage("system", basePrompt + identity);
        generation.Insert(pendingUserIndex, new ChatMessage("system", identity.Trim()));
        return generation;
    }
}

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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342

namespace Lilith.Core.Providers;

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

/// <summary>Conversation operations reject overlap rather than mixing sessions or snapshots.</summary>
public abstract partial class ProviderClient(Logger logger, ChatHistoryStore? historyStore = null, HttpClient? httpClient = null) : IDisposable
{
    private readonly bool _ownsHttp = httpClient is null;
    private readonly SemaphoreSlim _operation = new(1, 1);
    private bool _disposed;
    private readonly Dictionary<string, ILilithTool> _tools = new(StringComparer.Ordinal);
    internal IReadOnlyDictionary<string, ILilithTool> RegisteredTools => _tools;
    public Lilith.Core.Workspace.WorkspaceSession? Workspace { get; private set; }
    public Lilith.Core.WebResearch.IResearchBrowser? ResearchBrowser { get; private set; }
    public void ConfigureResearchBrowser(Lilith.Core.WebResearch.IResearchBrowser browser)
    {
        using var operation = EnterOperation();
        if (ResearchBrowser is not null) throw new InvalidOperationException("Research browser is fixed for this provider session.");
        ResearchBrowser = browser ?? throw new ArgumentNullException(nameof(browser));
    }
    public Lilith.Core.Scheduling.ScheduleSession? Schedules { get; private set; }
    internal bool ExecutingScheduledJob { get; private set; }
    public void ConfigureSchedules(Lilith.Core.Scheduling.ScheduleOptions options, string? scenarioRoot = null, TimeProvider? clock = null)
    {
        using var operation = EnterOperation();
        if (Schedules is not null) throw new InvalidOperationException("Schedules are fixed for this provider session.");
        Schedules = new(options, scenarioRoot, clock);
    }

    public void RecordScheduleEvent(Lilith.Core.Scheduling.ScheduleEvent item)
    {
        using var operation = EnterOperation();
        // Trusted application envelope; reminder text is data, never a new user instruction.
        History.Add("system", "Scheduler event (data): " + JsonSerializer.Serialize(new { item.Id, item.Name, item.Kind, item.AtUtc, item.Message }));
        SaveCore();
        Logger.WriteLine("Scheduler", item.Message, LogColors.Yellow);
    }

    public async Task<string> RunScheduledScenarioAsync(string name, IReadOnlyDictionary<string, string> inputs, CancellationToken ct = default)
    {
        using var operation = EnterOperation();
        ExecutingScheduledJob = true;
        try { return await RunScenarioCoreAsync(name, inputs, ct); }
        finally { ExecutingScheduledJob = false; }
    }
    public void ConfigureWorkspace(Lilith.Core.Workspace.WorkspaceOptions options)
    {
        using var operation = EnterOperation();
        if (Workspace is not null) throw new InvalidOperationException("Workspace mode and root are fixed for this provider session.");
        Workspace = new(options);
    }
    public async Task<string> ApproveWorkspaceAsync(string id, CancellationToken cancellationToken = default)
    {
        using var operation = EnterOperation();
        using var grant = (Workspace ?? throw new InvalidOperationException("No workspace configured.")).Authorize(id);
        return await RunScenarioCoreAsync("workspace_approve", new Dictionary<string, string> { ["bin_id"] = id }, cancellationToken);
    }
    public event Action<Lilith.Core.Scenarios.ScenarioProgress>? ScenarioProgress;
    internal void ReportScenario(Lilith.Core.Scenarios.ScenarioProgress progress)
    {
        ReportSubagent(progress);
        if (ScenarioProgress is not { } handlers) return;
        foreach (var handler in handlers.GetInvocationList().Cast<Action<Lilith.Core.Scenarios.ScenarioProgress>>())
            try { handler(progress); }
            catch (Exception ex) { Logger.WriteWarning("Scenario", "Progress observer failed: " + ex.Message); }
    }

    /// <summary>Fresh context with borrowed transport; never boots or reenters the parent.</summary>
    public virtual ProviderClient CreateScenarioBranch(string prompt, Logger branchLogger, ChatHistoryStore store) =>
        throw new NotSupportedException("This provider does not support scenario branches.");
    protected object[]? ToolDefinitions => _tools.Count == 0 ? null : _tools.Values.Select(t => (object)new
    {
        type = "function", function = new { name = t.Name, description = t.Description, parameters = t.Parameters }
    }).ToArray();

    public void RegisterTool(ILilithTool tool)
    {
        using var operation = EnterOperation();
        ArgumentNullException.ThrowIfNull(tool);
        if (string.IsNullOrWhiteSpace(tool.Name) || tool.Name.Length > 64 ||
            tool.Name.Any(c => !(char.IsAsciiLetterOrDigit(c) || c is '_' or '-')) ||
            tool.Parameters.ValueKind != JsonValueKind.Object)
            throw new ArgumentException("A tool requires a valid function name and JSON parameter schema.", nameof(tool));
        if (!_tools.TryAdd(tool.Name, tool)) throw new ArgumentException($"Tool '{tool.Name}' is already registered.", nameof(tool));
    }
    public HttpClient Http { get; } = httpClient ?? new() { Timeout = TimeSpan.FromMinutes(20) };
    public string Model { get; set; } = "gemma4";
    protected int NumCtx { get; set; } = 131072;
    public int ContextMax => NumCtx;
    public string SystemPrompt { get; protected set; } = string.Empty;
    /// <summary>Inspect only while idle. Use conversation methods to change an active session.</summary>
    public ChatHistory History { get; } = [];
    public ChatHistoryStore HistoryStore { get; } = historyStore ?? new ChatHistoryStore();
    public Logger Logger { get; } = logger;
    public string AgentName { get; set; } = "Lilith";
    public int ContextUsagePercent { get; private set; }
    public int CurrentContextTokens { get; private set; }
    public int ContextWarningThreshold { get; set; } = 60;
    public event Action<int>? OnContextHighUsage;

    public void ContextHighUsage(Func<int, string> message, string color = LogColors.Orange) =>
        OnContextHighUsage += pct => Logger.WriteLine("System", message(pct), color);

    protected void InitializeConversation()
    {
        History.Add("system", SystemPrompt);
        ContextHighUsage(pct => $"\u26a0 Context window is {pct}% full — history is getting long.");
    }

    private IDisposable EnterOperation()
    {
        var operation = _operation.EnterOrThrow("A conversation operation is already in progress.");
        if (_disposed) { operation.Dispose(); throw new ObjectDisposedException(GetType().Name); }
        return operation;
    }

    public void NewConversation()
    {
        using var operation = EnterOperation();
        SaveCore();
        HistoryStore.StartNewSession();
        ClearCore();
        Logger.WriteLine("System", "New conversation started.", LogColors.Cyan);
    }

    public void SaveConversation() => SaveCurrentConversation();
    public IReadOnlyList<ChatSessionSummary> ListConversations() => ListSavedConversations();
    public bool LoadConversation(int displayIndex) => LoadSavedConversation(displayIndex);
    public bool LoadConversation(string id) => LoadSavedConversation(id);
    public void ClearHistory() { using var operation = EnterOperation(); ClearCore(); }

    private void ClearCore()
    {
        History.Clear();
        ResetUsage();
        if (!string.IsNullOrWhiteSpace(SystemPrompt)) History.Add("system", SystemPrompt);
    }

    private void ResetUsage() { CurrentContextTokens = 0; ContextUsagePercent = 0; }
    public void StartNewSession() { using var operation = EnterOperation(); HistoryStore.StartNewSession(); }
    public void SaveCurrentConversation() { using var operation = EnterOperation(); SaveCore(); }

    private void SaveCore()
    {
        try
        {
            if (History.Any(m => !m.Role.Equals("system", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(m.Content)))
                HistoryStore.SaveSession(Model, History);
        }
        catch (Exception ex) { Logger.WriteWarning("History", $"Could not save chat history: {ex.Message}"); }
    }

    public IReadOnlyList<ChatSessionSummary> ListSavedConversations()
    {
        using var operation = EnterOperation();
        return HistoryStore.ListSessions();
    }

    public bool LoadSavedConversation(int displayIndex)
    {
        using var operation = EnterOperation();
        var sessions = HistoryStore.ListSessions();
        return displayIndex >= 1 && displayIndex <= sessions.Count && LoadCore(sessions[displayIndex - 1].Id);
    }

    public bool LoadSavedConversation(string id) { using var operation = EnterOperation(); return LoadCore(id); }

    private bool LoadCore(string id)
    {
        string previousId = HistoryStore.CurrentSessionId;
        try
        {
            var session = HistoryStore.LoadSession(id);
            if (session is null) return false;
            var messages = session.Messages.Select(m => m.ToChatMessage()).ToList();
            if (messages[0].Role != "system")
            {
                if (string.IsNullOrWhiteSpace(SystemPrompt)) throw new InvalidDataException("System prompt content is missing.");
                messages.Insert(0, new ChatMessage("system", SystemPrompt));
            }
            History.Clear();
            History.AddRange(messages);
            ResetUsage();
            return true;
        }
        catch (Exception ex)
        {
            HistoryStore.UseSession(previousId);
            Logger.WriteWarning("History", $"Could not load chat history: {ex.Message}");
            return false;
        }
    }

    protected abstract Task<ChatChunk?> GenerateReplyAsync(List<ChatMessage> messages);
    protected virtual Task<ChatChunk?> GenerateReplyAsync(List<ChatMessage> messages, CancellationToken cancellationToken) =>
        GenerateReplyAsync(messages);

    public async Task<string> StreamReply(string userInput, List<string>? images = null, CancellationToken cancellationToken = default)
    {
        using var operation = EnterOperation();
        return await StreamReplyCoreAsync(userInput, images, cancellationToken);
    }

    /// <summary>Application-requested scenario dispatch; no model decision is needed to start it.</summary>
    public async Task<string> RunScenarioAsync(string scenarioName, IReadOnlyDictionary<string, string>? inputs = null,
        CancellationToken cancellationToken = default)
    {
        using var operation = EnterOperation();
        return await RunScenarioCoreAsync(scenarioName, inputs, cancellationToken);
    }

    private async Task<string> RunScenarioCoreAsync(string scenarioName, IReadOnlyDictionary<string, string>? inputs,
        CancellationToken cancellationToken)
    {
        if (!_tools.TryGetValue("run_scenario", out var tool) || tool is not Lilith.Core.Scenarios.RunScenarioTool)
            throw new InvalidOperationException("Register scenario support before running a scenario.");
        var arguments = JsonSerializer.SerializeToElement(new { scenario_name = scenarioName, inputs = inputs ?? new Dictionary<string, string>() });
        var call = new ToolCall(new ToolFunction("run_scenario", arguments), "application-" + Guid.NewGuid().ToString("N"));
        var dispatch = new ChatChunk(new ChatMessage("assistant", "", ToolCalls: [call]), true, null, null);
        Logger.WriteLine("System", "Application requested scenario: " + scenarioName, LogColors.Cyan);
        return await StreamReplyCoreAsync(scenarioName == "greeting" ? "Please greet the user using the greeting scenario." : "Run " + scenarioName + " scenario.",
            null, cancellationToken, dispatch);
    }

    private async Task<string> StreamReplyCoreAsync(string userInput, List<string>? images, CancellationToken cancellationToken,
        ChatChunk? applicationDispatch = null)
    {
        bool requireScenarioSuccess = applicationDispatch is not null;
        if (string.IsNullOrWhiteSpace(userInput)) throw new ArgumentException("User input cannot be blank.", nameof(userInput));
        var userMessage = new ChatMessage("user", userInput, Images: images is null ? null : [.. images]);
        var requestHistory = History.Select(m => m.Snapshot()).ToList();
        requestHistory.Add(userMessage);
        Logger.WriteLine("User", $"User: {userInput}", LogColors.Green);
        ChatChunk? chunk;
        int originalCount = requestHistory.Count - 1;
        string personalityBasePrompt = requestHistory.FirstOrDefault()?.Content ?? SystemPrompt;
        int rounds = 0;
        while (true)
        {
            cancellationToken.ThrowIfCancellationRequested();
            var generationHistory = PreparePersonalityPrompt(requestHistory, personalityBasePrompt, originalCount);
            chunk = applicationDispatch ?? await GenerateReplyAsync(generationHistory, cancellationToken);
            applicationDispatch = null;
            cancellationToken.ThrowIfCancellationRequested();
            if (chunk is not { Done: true, Message.Role: "assistant" } ||
                chunk.PromptTokens is < 0 || chunk.CompletionTokens is < 0)
                throw new InvalidDataException("The model provider returned an invalid assistant response.");
            if (chunk.Message.ToolCalls is not { Count: > 0 } calls) break;
            if (++rounds > 8 || calls.Count > 16)
                throw new InvalidDataException("The model exceeded the tool execution limit.");
            foreach (var call in calls)
                if (call?.Function is null || string.IsNullOrWhiteSpace(call.Function.Name) ||
                    call.Function.Arguments.ValueKind != JsonValueKind.Object)
                    throw new InvalidDataException("The model returned a malformed tool call.");
            if (calls.Count != 1 && calls.Any(c => _tools.TryGetValue(c.Function.Name, out var candidate) && candidate is ITurnResultTool))
                throw new InvalidDataException("Run a scenario in its own tool batch so its final output is unambiguous.");
            requestHistory.Add(chunk.Message with { Content = chunk.Message.Content ?? string.Empty });
            string? exactReply = null;
            foreach (var call in calls)
            {
                cancellationToken.ThrowIfCancellationRequested();
                string result;
                if (!_tools.TryGetValue(call.Function.Name, out var tool))
                    result = JsonSerializer.Serialize(new { error = "Unknown tool: " + call.Function.Name });
                else
                {
                    using var deadline = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                    deadline.CancelAfter(tool is ITurnResultTool timed ? timed.ExecutionTimeout : TimeSpan.FromSeconds(30));
                    try
                    {
                        // Await actual completion: custom tools must cooperate with cancellation.
                        if (tool is ITurnResultTool turnTool)
                        {
                            var outcome = await turnTool.ExecuteResultAsync(call.Function.Arguments, deadline.Token);
                            deadline.Token.ThrowIfCancellationRequested();
                            if (requireScenarioSuccess && call.Function.Name == "run_scenario")
                            {
                                using var status = JsonDocument.Parse(outcome.Content);
                                string? scenarioStatus = status.RootElement.GetProperty("status").GetString();
                                if (scenarioStatus != "completed" && !(ExecutingScheduledJob && scenarioStatus == "needs_approval"))
                                    throw new InvalidDataException("Configured scenario did not complete: " + outcome.Content);
                            }
                            result = outcome.Content;
                            if (outcome.ExactReply is { } exact)
                            {
                                if (exactReply is not null) throw new InvalidDataException("Only one exact scenario output is allowed per tool batch.");
                                exactReply = exact;
                            }
                        }
                        else result = await tool.ExecuteAsync(call.Function.Arguments, deadline.Token);
                        deadline.Token.ThrowIfCancellationRequested();
                    }
                    catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) { throw; }
                    catch (Exception ex) when (!requireScenarioSuccess && ex is not OutOfMemoryException)
                    {
                        result = JsonSerializer.Serialize(new { error = ex is OperationCanceledException ? "Tool execution canceled or timed out." : ex.Message });
                    }
                }
                requestHistory.Add(new ChatMessage("tool", result ?? string.Empty, ToolName: call.Function.Name, ToolCallId: call.Id));
            }
            if (exactReply is not null)
            {
                chunk = new ChatChunk(new ChatMessage("assistant", exactReply), true, null, null);
                break;
            }
        }
        cancellationToken.ThrowIfCancellationRequested();
        if (chunk is not { Done: true, Message: { Role: "assistant", Content: not null } } ||
            string.IsNullOrWhiteSpace(chunk.Message.Content) || chunk.PromptTokens is < 0 || chunk.CompletionTokens is < 0)
            throw new InvalidDataException("The model provider did not return a complete nonempty assistant reply with valid token counts.");
        string reply = chunk.Message.Content;
        // Commit only after a successful final answer.
        requestHistory[originalCount] = userMessage with { Tokens = chunk.PromptTokens };
        History.AddRange(requestHistory.Skip(originalCount).Select(m => m.Snapshot()));
        History.Add("assistant", reply, chunk.CompletionTokens);
        SaveCore();
        Logger.WriteLine(AgentName, $"{AgentName}: {reply}", LogColors.Yellow);
        ResetUsage();
        if (chunk.PromptTokens is { } prompt && chunk.CompletionTokens is { } completion && NumCtx > 0)
        {
            CurrentContextTokens = (int)Math.Min(int.MaxValue, (long)prompt + completion);
            ContextUsagePercent = (int)Math.Min(int.MaxValue, (long)CurrentContextTokens * 100 / NumCtx);
            if (ContextUsagePercent >= ContextWarningThreshold && OnContextHighUsage is { } handlers)
                foreach (var handler in handlers.GetInvocationList().Cast<Action<int>>())
                    try { handler(ContextUsagePercent); }
                    catch (Exception ex) { Logger.WriteWarning("System", $"Context warning callback failed: {ex.Message}"); }
        }
        return reply;
    }

    public void Dispose()
    {
        using var operation = _operation.EnterOrThrow("Cannot dispose a provider during a conversation operation.");
        if (_disposed) return;
        _disposed = true;
        Schedules?.Dispose();
        if (_ownsHttp) Http.Dispose();
        GC.SuppressFinalize(this);
    }

}

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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340

namespace Lilith.Core.Providers;

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

/// <summary>Conversation operations reject overlap rather than mixing sessions or snapshots.</summary>
public abstract partial class ProviderClient(Logger logger, ChatHistoryStore? historyStore = null, HttpClient? httpClient = null) : IDisposable
{
    private readonly bool _ownsHttp = httpClient is null;
    private readonly SemaphoreSlim _operation = new(1, 1);
    private bool _disposed;
    private readonly Dictionary<string, ILilithTool> _tools = new(StringComparer.Ordinal);
    internal IReadOnlyDictionary<string, ILilithTool> RegisteredTools => _tools;
    public Lilith.Core.Workspace.WorkspaceSession? Workspace { get; private set; }
    public Lilith.Core.WebResearch.IResearchBrowser? ResearchBrowser { get; private set; }
    public void ConfigureResearchBrowser(Lilith.Core.WebResearch.IResearchBrowser browser)
    {
        using var operation = EnterOperation();
        if (ResearchBrowser is not null) throw new InvalidOperationException("Research browser is fixed for this provider session.");
        ResearchBrowser = browser ?? throw new ArgumentNullException(nameof(browser));
    }
    public Lilith.Core.Scheduling.ScheduleSession? Schedules { get; private set; }
    internal bool ExecutingScheduledJob { get; private set; }
    public void ConfigureSchedules(Lilith.Core.Scheduling.ScheduleOptions options, string? scenarioRoot = null, TimeProvider? clock = null)
    {
        using var operation = EnterOperation();
        if (Schedules is not null) throw new InvalidOperationException("Schedules are fixed for this provider session.");
        Schedules = new(options, scenarioRoot, clock);
    }

    public void RecordScheduleEvent(Lilith.Core.Scheduling.ScheduleEvent item)
    {
        using var operation = EnterOperation();
        // Trusted application envelope; reminder text is data, never a new user instruction.
        History.Add("system", "Scheduler event (data): " + JsonSerializer.Serialize(new { item.Id, item.Name, item.Kind, item.AtUtc, item.Message }));
        SaveCore();
        Logger.WriteLine("Scheduler", item.Message, LogColors.Yellow);
    }

    public async Task<string> RunScheduledScenarioAsync(string name, IReadOnlyDictionary<string, string> inputs, CancellationToken ct = default)
    {
        using var operation = EnterOperation();
        ExecutingScheduledJob = true;
        try { return await RunScenarioCoreAsync(name, inputs, ct); }
        finally { ExecutingScheduledJob = false; }
    }
    public void ConfigureWorkspace(Lilith.Core.Workspace.WorkspaceOptions options)
    {
        using var operation = EnterOperation();
        if (Workspace is not null) throw new InvalidOperationException("Workspace mode and root are fixed for this provider session.");
        Workspace = new(options);
    }
    public async Task<string> ApproveWorkspaceAsync(string id, CancellationToken cancellationToken = default)
    {
        using var operation = EnterOperation();
        using var grant = (Workspace ?? throw new InvalidOperationException("No workspace configured.")).Authorize(id);
        return await RunScenarioCoreAsync("workspace_approve", new Dictionary<string, string> { ["bin_id"] = id }, cancellationToken);
    }
    public event Action<Lilith.Core.Scenarios.ScenarioProgress>? ScenarioProgress;
    internal void ReportScenario(Lilith.Core.Scenarios.ScenarioProgress progress)
    {
        ReportSubagent(progress);
        if (ScenarioProgress is not { } handlers) return;
        foreach (var handler in handlers.GetInvocationList().Cast<Action<Lilith.Core.Scenarios.ScenarioProgress>>())
            try { handler(progress); }
            catch (Exception ex) { Logger.WriteWarning("Scenario", "Progress observer failed: " + ex.Message); }
    }

    /// <summary>Fresh context with borrowed transport; never boots or reenters the parent.</summary>
    public virtual ProviderClient CreateScenarioBranch(string prompt, Logger branchLogger, ChatHistoryStore store) =>
        throw new NotSupportedException("This provider does not support scenario branches.");
    protected object[]? ToolDefinitions => _tools.Count == 0 ? null : _tools.Values.Select(t => (object)new
    {
        type = "function", function = new { name = t.Name, description = t.Description, parameters = t.Parameters }
    }).ToArray();

    public void RegisterTool(ILilithTool tool)
    {
        using var operation = EnterOperation();
        ArgumentNullException.ThrowIfNull(tool);
        if (string.IsNullOrWhiteSpace(tool.Name) || tool.Name.Length > 64 ||
            tool.Name.Any(c => !(char.IsAsciiLetterOrDigit(c) || c is '_' or '-')) ||
            tool.Parameters.ValueKind != JsonValueKind.Object)
            throw new ArgumentException("A tool requires a valid function name and JSON parameter schema.", nameof(tool));
        if (!_tools.TryAdd(tool.Name, tool)) throw new ArgumentException($"Tool '{tool.Name}' is already registered.", nameof(tool));
    }
    public HttpClient Http { get; } = httpClient ?? new() { Timeout = TimeSpan.FromMinutes(20) };
    public string Model { get; set; } = "gemma4";
    protected int NumCtx { get; set; } = 131072;
    public int ContextMax => NumCtx;
    public string SystemPrompt { get; protected set; } = string.Empty;
    /// <summary>Inspect only while idle. Use conversation methods to change an active session.</summary>
    public ChatHistory History { get; } = [];
    public ChatHistoryStore HistoryStore { get; } = historyStore ?? new ChatHistoryStore();
    public Logger Logger { get; } = logger;
    public string AgentName { get; set; } = "Lilith";
    public int ContextUsagePercent { get; private set; }
    public int CurrentContextTokens { get; private set; }
    public int ContextWarningThreshold { get; set; } = 60;
    public event Action<int>? OnContextHighUsage;

    public void ContextHighUsage(Func<int, string> message, string color = LogColors.Orange) =>
        OnContextHighUsage += pct => Logger.WriteLine("System", message(pct), color);

    protected void InitializeConversation()
    {
        History.Add("system", SystemPrompt);
        ContextHighUsage(pct => $"\u26a0 Context window is {pct}% full — history is getting long.");
    }

    private IDisposable EnterOperation()
    {
        var operation = _operation.EnterOrThrow("A conversation operation is already in progress.");
        if (_disposed) { operation.Dispose(); throw new ObjectDisposedException(GetType().Name); }
        return operation;
    }

    public void NewConversation()
    {
        using var operation = EnterOperation();
        SaveCore();
        HistoryStore.StartNewSession();
        ClearCore();
        Logger.WriteLine("System", "New conversation started.", LogColors.Cyan);
    }

    public void SaveConversation() => SaveCurrentConversation();
    public IReadOnlyList<ChatSessionSummary> ListConversations() => ListSavedConversations();
    public bool LoadConversation(int displayIndex) => LoadSavedConversation(displayIndex);
    public bool LoadConversation(string id) => LoadSavedConversation(id);
    public void ClearHistory() { using var operation = EnterOperation(); ClearCore(); }

    private void ClearCore()
    {
        History.Clear();
        ResetUsage();
        if (!string.IsNullOrWhiteSpace(SystemPrompt)) History.Add("system", SystemPrompt);
    }

    private void ResetUsage() { CurrentContextTokens = 0; ContextUsagePercent = 0; }
    public void StartNewSession() { using var operation = EnterOperation(); HistoryStore.StartNewSession(); }
    public void SaveCurrentConversation() { using var operation = EnterOperation(); SaveCore(); }

    private void SaveCore()
    {
        try
        {
            if (History.Any(m => !m.Role.Equals("system", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(m.Content)))
                HistoryStore.SaveSession(Model, History);
        }
        catch (Exception ex) { Logger.WriteWarning("History", $"Could not save chat history: {ex.Message}"); }
    }

    public IReadOnlyList<ChatSessionSummary> ListSavedConversations()
    {
        using var operation = EnterOperation();
        return HistoryStore.ListSessions();
    }

    public bool LoadSavedConversation(int displayIndex)
    {
        using var operation = EnterOperation();
        var sessions = HistoryStore.ListSessions();
        return displayIndex >= 1 && displayIndex <= sessions.Count && LoadCore(sessions[displayIndex - 1].Id);
    }

    public bool LoadSavedConversation(string id) { using var operation = EnterOperation(); return LoadCore(id); }

    private bool LoadCore(string id)
    {
        string previousId = HistoryStore.CurrentSessionId;
        try
        {
            var session = HistoryStore.LoadSession(id);
            if (session is null) return false;
            var messages = session.Messages.Select(m => m.ToChatMessage()).ToList();
            if (messages[0].Role != "system")
            {
                if (string.IsNullOrWhiteSpace(SystemPrompt)) throw new InvalidDataException("System prompt content is missing.");
                messages.Insert(0, new ChatMessage("system", SystemPrompt));
            }
            History.Clear();
            History.AddRange(messages);
            ResetUsage();
            return true;
        }
        catch (Exception ex)
        {
            HistoryStore.UseSession(previousId);
            Logger.WriteWarning("History", $"Could not load chat history: {ex.Message}");
            return false;
        }
    }

    protected abstract Task<ChatChunk?> GenerateReplyAsync(List<ChatMessage> messages);
    protected virtual Task<ChatChunk?> GenerateReplyAsync(List<ChatMessage> messages, CancellationToken cancellationToken) =>
        GenerateReplyAsync(messages);

    public async Task<string> StreamReply(string userInput, List<string>? images = null, CancellationToken cancellationToken = default)
    {
        using var operation = EnterOperation();
        return await StreamReplyCoreAsync(userInput, images, cancellationToken);
    }

    /// <summary>Application-requested scenario dispatch; no model decision is needed to start it.</summary>
    public async Task<string> RunScenarioAsync(string scenarioName, IReadOnlyDictionary<string, string>? inputs = null,
        CancellationToken cancellationToken = default)
    {
        using var operation = EnterOperation();
        return await RunScenarioCoreAsync(scenarioName, inputs, cancellationToken);
    }

    private async Task<string> RunScenarioCoreAsync(string scenarioName, IReadOnlyDictionary<string, string>? inputs,
        CancellationToken cancellationToken)
    {
        if (!_tools.TryGetValue("run_scenario", out var tool) || tool is not Lilith.Core.Scenarios.RunScenarioTool)
            throw new InvalidOperationException("Register scenario support before running a scenario.");
        var arguments = JsonSerializer.SerializeToElement(new { scenario_name = scenarioName, inputs = inputs ?? new Dictionary<string, string>() });
        var call = new ToolCall(new ToolFunction("run_scenario", arguments), "application-" + Guid.NewGuid().ToString("N"));
        var dispatch = new ChatChunk(new ChatMessage("assistant", "", ToolCalls: [call]), true, null, null);
        Logger.WriteLine("System", "Application requested scenario: " + scenarioName, LogColors.Cyan);
        return await StreamReplyCoreAsync(scenarioName == "greeting" ? "Please greet the user using the greeting scenario." : "Run " + scenarioName + " scenario.",
            null, cancellationToken, dispatch);
    }

    private async Task<string> StreamReplyCoreAsync(string userInput, List<string>? images, CancellationToken cancellationToken,
        ChatChunk? applicationDispatch = null)
    {
        bool requireScenarioSuccess = applicationDispatch is not null;
        if (string.IsNullOrWhiteSpace(userInput)) throw new ArgumentException("User input cannot be blank.", nameof(userInput));
        var userMessage = new ChatMessage("user", userInput, Images: images is null ? null : [.. images]);
        var requestHistory = History.Select(m => m.Snapshot()).ToList();
        requestHistory.Add(userMessage);
        Logger.WriteLine("User", $"User: {userInput}", LogColors.Green);
        ChatChunk? chunk;
        int originalCount = requestHistory.Count - 1;
        int rounds = 0;
        while (true)
        {
            cancellationToken.ThrowIfCancellationRequested();
            chunk = applicationDispatch ?? await GenerateReplyAsync(requestHistory, cancellationToken);
            applicationDispatch = null;
            cancellationToken.ThrowIfCancellationRequested();
            if (chunk is not { Done: true, Message.Role: "assistant" } ||
                chunk.PromptTokens is < 0 || chunk.CompletionTokens is < 0)
                throw new InvalidDataException("The model provider returned an invalid assistant response.");
            if (chunk.Message.ToolCalls is not { Count: > 0 } calls) break;
            if (++rounds > 8 || calls.Count > 16)
                throw new InvalidDataException("The model exceeded the tool execution limit.");
            foreach (var call in calls)
                if (call?.Function is null || string.IsNullOrWhiteSpace(call.Function.Name) ||
                    call.Function.Arguments.ValueKind != JsonValueKind.Object)
                    throw new InvalidDataException("The model returned a malformed tool call.");
            if (calls.Count != 1 && calls.Any(c => _tools.TryGetValue(c.Function.Name, out var candidate) && candidate is ITurnResultTool))
                throw new InvalidDataException("Run a scenario in its own tool batch so its final output is unambiguous.");
            requestHistory.Add(chunk.Message with { Content = chunk.Message.Content ?? string.Empty });
            string? exactReply = null;
            foreach (var call in calls)
            {
                cancellationToken.ThrowIfCancellationRequested();
                string result;
                if (!_tools.TryGetValue(call.Function.Name, out var tool))
                    result = JsonSerializer.Serialize(new { error = "Unknown tool: " + call.Function.Name });
                else
                {
                    using var deadline = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                    deadline.CancelAfter(tool is ITurnResultTool timed ? timed.ExecutionTimeout : TimeSpan.FromSeconds(30));
                    try
                    {
                        // Await actual completion: custom tools must cooperate with cancellation.
                        if (tool is ITurnResultTool turnTool)
                        {
                            var outcome = await turnTool.ExecuteResultAsync(call.Function.Arguments, deadline.Token);
                            deadline.Token.ThrowIfCancellationRequested();
                            if (requireScenarioSuccess && call.Function.Name == "run_scenario")
                            {
                                using var status = JsonDocument.Parse(outcome.Content);
                                string? scenarioStatus = status.RootElement.GetProperty("status").GetString();
                                if (scenarioStatus != "completed" && !(ExecutingScheduledJob && scenarioStatus == "needs_approval"))
                                    throw new InvalidDataException("Configured scenario did not complete: " + outcome.Content);
                            }
                            result = outcome.Content;
                            if (outcome.ExactReply is { } exact)
                            {
                                if (exactReply is not null) throw new InvalidDataException("Only one exact scenario output is allowed per tool batch.");
                                exactReply = exact;
                            }
                        }
                        else result = await tool.ExecuteAsync(call.Function.Arguments, deadline.Token);
                        deadline.Token.ThrowIfCancellationRequested();
                    }
                    catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) { throw; }
                    catch (Exception ex) when (!requireScenarioSuccess && ex is not OutOfMemoryException)
                    {
                        result = JsonSerializer.Serialize(new { error = ex is OperationCanceledException ? "Tool execution canceled or timed out." : ex.Message });
                    }
                }
                requestHistory.Add(new ChatMessage("tool", result ?? string.Empty, ToolName: call.Function.Name, ToolCallId: call.Id));
            }
            if (exactReply is not null)
            {
                chunk = new ChatChunk(new ChatMessage("assistant", exactReply), true, null, null);
                break;
            }
        }
        cancellationToken.ThrowIfCancellationRequested();
        if (chunk is not { Done: true, Message: { Role: "assistant", Content: not null } } ||
            string.IsNullOrWhiteSpace(chunk.Message.Content) || chunk.PromptTokens is < 0 || chunk.CompletionTokens is < 0)
            throw new InvalidDataException("The model provider did not return a complete nonempty assistant reply with valid token counts.");
        string reply = chunk.Message.Content;
        // Commit only after a successful final answer.
        requestHistory[originalCount] = userMessage with { Tokens = chunk.PromptTokens };
        History.AddRange(requestHistory.Skip(originalCount).Select(m => m.Snapshot()));
        History.Add("assistant", reply, chunk.CompletionTokens);
        SaveCore();
        Logger.WriteLine(AgentName, $"{AgentName}: {reply}", LogColors.Yellow);
        ResetUsage();
        if (chunk.PromptTokens is { } prompt && chunk.CompletionTokens is { } completion && NumCtx > 0)
        {
            CurrentContextTokens = (int)Math.Min(int.MaxValue, (long)prompt + completion);
            ContextUsagePercent = (int)Math.Min(int.MaxValue, (long)CurrentContextTokens * 100 / NumCtx);
            if (ContextUsagePercent >= ContextWarningThreshold && OnContextHighUsage is { } handlers)
                foreach (var handler in handlers.GetInvocationList().Cast<Action<int>>())
                    try { handler(ContextUsagePercent); }
                    catch (Exception ex) { Logger.WriteWarning("System", $"Context warning callback failed: {ex.Message}"); }
        }
        return reply;
    }

    public void Dispose()
    {
        using var operation = _operation.EnterOrThrow("Cannot dispose a provider during a conversation operation.");
        if (_disposed) return;
        _disposed = true;
        Schedules?.Dispose();
        if (_ownsHttp) Http.Dispose();
        GC.SuppressFinalize(this);
    }

}