Only the delta.

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

# Build output and local SDK state
**/bin/
**/obj/
/Admin/Build/
/.dotnet/

# Machine-specific IDE settings
.vs/
.idea/
*.user
*.suo

# Generated checks, downloads, and media
/Admin/TestResults/
/Admin/Downloads/
/Admin/Videos/
*.onnx
*.onnx.data

# Local credentials and tooling state
.env
.env.*
!.env.example
/.aws/
/.codex/

1
2
3
4
5
6
7

<Project>
  <!-- V1 baseline. Set VersionPrefix=2.0.0 and VersionSuffix=alpha.1 on v2. -->
  <PropertyGroup>
    <VersionPrefix>1.0.1</VersionPrefix>
    <VersionSuffix></VersionSuffix>
  </PropertyGroup>
</Project>

1
2
3
4
5
6
7
8
9
10
11
12
13

{
  "version": 1,
  "isRoot": true,
  "tools": {
    "csharpier": {
      "version": "1.3.0",
      "commands": [
        "csharpier"
      ],
      "rollForward": false
    }
  }
}

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

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <RootNamespace>LilithConsole</RootNamespace>
  </PropertyGroup>

  <ItemGroup>
    <ProjectReference Include="..\..\..\Lilith\Agent\Agent.csproj" />
  </ItemGroup>

</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

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);
                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);
                    }
                }
                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

using System.Text.Json;
using System.Text.RegularExpressions;
using Lilith.Core.Logging;
using Lilith.Core.Ollama;
using Lilith.Core.Extensions;
using Lilith.Agent;

namespace LilithConsole.Setup;

public record ConsoleSettings(string? AgentName = null, string? Model = null)
{
    public bool IsValid() => (AgentName is null || (!string.IsNullOrWhiteSpace(AgentName) && AgentName.Length <= 80 && !AgentName.Any(char.IsControl))) &&
        (Model is null || (Model.Length <= 200 && RegexPatterns.ModelIdentifier().IsMatch(Model)));
}

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

using System.Text.Json;
using System.Text.RegularExpressions;
using Lilith.Core.Logging;
using Lilith.Core.Ollama;
using Lilith.Core.Extensions;
using Lilith.Agent;

namespace LilithConsole.Setup;

/// <summary>Checks actual installation/model state on every launch, independent of saved preferences.</summary>
public sealed class ConsoleSetup(TextReader input, TextWriter output, ISetupServices services, Logger logger, string settingsPath)
{
    public static readonly IReadOnlyList<string> Models = Array.AsReadOnly<string>(["gemma4", "llama3.2", "qwen3:4b", "phi4-mini"]);

    public async Task<LilithCredentials?> RunAsync()
    {
        using var totalTimer = new ConsoleSetupTimer(logger);
        bool installed = await logger.TimeStageAsync("Installation check", () => Task.FromResult(services.IsInstalled()));
        if (!installed)
        {
            if (!await logger.TimeStageAsync("Installation choice", () => Task.FromResult(Confirm("Would you like to download and install Ollama? [y/N, exit]: ")))) return null;
            await logger.TimeStageAsync("Ollama installation", services.InstallAsync);
            if (!services.IsInstalled()) throw new InvalidOperationException("Ollama executable was not found after installation.");
        }
        else output.WriteLine("Ollama already installed; skipping installation.");
        await logger.TimeStageAsync("Server startup/check", services.EnsureServerAsync);

        ConsoleSettings settings = await logger.TimeStageAsync("Preferences load", () => Task.FromResult(Load()));
        if (settings.AgentName is null)
        {
            output.Write("Agent name (Enter for Lilith, /exit to leave): ");
            string? name = await logger.TimeStageAsync("Agent name selection", () => Task.FromResult(input.ReadLine()));
            if (name is null || name.Trim().Equals("/exit", StringComparison.OrdinalIgnoreCase)) return null;
            name = name.Trim();
            if (name.Length > 80 || name.Any(char.IsControl)) throw new ArgumentException("Agent name must be at most 80 characters without control characters.");
            settings = settings with { AgentName = name.Length == 0 ? "Lilith" : name };
            Save(settings); // Persist identity even if the application closes before a model is ready.
        }
        output.WriteLine($"Agent name: {settings.AgentName}");
        string? overrideModel = Environment.GetEnvironmentVariable("LILITH_MODEL");
        if (!string.IsNullOrWhiteSpace(overrideModel)) settings = settings with { Model = overrideModel.Trim() };

        bool available = settings.Model is not null &&
            await logger.TimeStageAsync("Saved model check", () => services.HasModelAsync(settings.Model));
        if (!available)
        {
            if (settings.Model is not null) output.WriteLine($"Model '{settings.Model}' is not installed. Choose a model to continue.");
            string? selected = await logger.TimeStageAsync("Model selection", () => Task.FromResult(SelectModel()));
            if (selected is null) return null;
            settings = settings with { Model = selected };
            Save(settings); // Remember selection even if a download is interrupted.
            available = await logger.TimeStageAsync("Selected model check", () => services.HasModelAsync(selected));
            if (!available)
            {
                if (!await logger.TimeStageAsync("Download choice", () => Task.FromResult(Confirm($"Download model '{selected}'? [y/N, exit]: ")))) return null;
                await logger.TimeStageAsync("Model download", () => services.DownloadAsync(selected));
                if (!await logger.TimeStageAsync("Downloaded model validation", () => services.HasModelAsync(selected)))
                    throw new InvalidOperationException("Model is still unavailable after download. Relaunch setup to retry.");
            }
            else output.WriteLine($"Model '{selected}' already installed; skipping download.");
        }
        else output.WriteLine($"Model '{settings.Model}' already installed; skipping selection and download.");
        Save(settings);
        totalTimer.Completed = true;
        return new LilithCredentials(settings.Model!,
            $"You are {settings.AgentName}, a helpful AI assistant. Greet the user warmly when the conversation begins.", settings.AgentName!);
    }

    private string? SelectModel()
    {
        while (true)
        {
            output.WriteLine("Choose a model:");
            for (int i = 0; i < Models.Count; i++) output.WriteLine($"{i + 1}. {Models[i]}");
            output.WriteLine("5. Custom model\n0. Exit");
            output.Write("Selection: ");
            string? selection = input.ReadLine()?.Trim();
            if (selection is null || selection.Equals("exit", StringComparison.OrdinalIgnoreCase) || selection == "0") return null;
            if (int.TryParse(selection, out int index) && index is >= 1 and <= 4) return Models[index - 1];
            if (selection == "5")
            {
                output.Write("Custom model name/tag (or exit): ");
                string? custom = input.ReadLine()?.Trim();
                if (custom is null || custom.Equals("exit", StringComparison.OrdinalIgnoreCase)) return null;
                if (custom.Length <= 200 && RegexPatterns.OllamaModelIdentifier().IsMatch(custom)) return custom;
                output.WriteLine("Enter a valid model name, for example llama3.2:1b.");
            }
            else output.WriteLine("Choose 1–5, or 0 to exit.");
        }
    }

    private bool Confirm(string question)
    {
        while (true)
        {
            output.Write(question);
            string? answer = input.ReadLine()?.Trim().ToLowerInvariant();
            if (answer is null or "" or "n" or "no" or "exit" or "0") return false;
            if (answer is "y" or "yes") return true;
            output.WriteLine("Please enter y, n, or exit.");
        }
    }

    private ConsoleSettings Load()
    {
        if (!File.Exists(settingsPath)) return new();
        try
        {
            return JsonSettings.Load<ConsoleSettings>(settingsPath, settings => settings.IsValid());
        }
        catch (JsonException ex) { output.WriteLine($"Saved settings could not be read ({ex.Message}); setup will ask again."); return new(); }
    }

    private void Save(ConsoleSettings settings)
    {
        JsonSettings.Save(settingsPath, settings);
    }
}

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

using System.Text.Json;
using System.Text.RegularExpressions;
using Lilith.Core.Logging;
using Lilith.Core.Ollama;
using Lilith.Core.Extensions;
using Lilith.Agent;

namespace LilithConsole.Setup;

internal sealed class ConsoleSetupTimer(Logger logger) : IDisposable
{
    private readonly System.Diagnostics.Stopwatch _timer = System.Diagnostics.Stopwatch.StartNew();
    public bool Completed { get; set; }
    public void Dispose()
    {
        _timer.Stop();
        logger.WriteLine("Boot", $"Console setup {(Completed ? "finished" : "stopped")} — elapsed {_timer.Elapsed.TotalSeconds:F2}s", LogColors.Gray);
    }
}

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

using System.Text.Json;
using System.Text.RegularExpressions;
using Lilith.Core.Logging;
using Lilith.Core.Ollama;
using Lilith.Core.Extensions;
using Lilith.Agent;

namespace LilithConsole.Setup;

public interface ISetupServices
{
    bool IsInstalled();
    Task InstallAsync();
    Task EnsureServerAsync();
    Task<bool> HasModelAsync(string model);
    Task DownloadAsync(string model);
}

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

using System.Text.Json;
using System.Text.RegularExpressions;
using Lilith.Core.Logging;
using Lilith.Core.Ollama;
using Lilith.Core.Extensions;
using Lilith.Agent;

namespace LilithConsole.Setup;

public sealed class OllamaSetupServices(Logger logger) : ISetupServices
{
    public bool IsInstalled() => OllamaClient.IsOllamaInstalled();
    public Task InstallAsync() => OllamaClient.InstallAsync(logger);
    public Task EnsureServerAsync() => OllamaClient.EnsureServerAsync(logger);
    public Task<bool> HasModelAsync(string model) => OllamaClient.IsModelAvailableAsync(model);
    public Task DownloadAsync(string model) => OllamaClient.DownloadModelAsync(model, logger);
}

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 System.Text.Json;
using System.Text.RegularExpressions;
using Lilith.Agent;
using Lilith.Core.LMStudio;
using Lilith.Core.Logging;
using Lilith.Core.Extensions;

namespace LilithConsole.Setup;

public static class ProviderSetup
{
    public static async Task<LilithCredentials?> RunAsync(TextReader input, TextWriter output, Logger logger, string settingsPath)
    {
        string? selected = Environment.GetEnvironmentVariable("LILITH_PROVIDER");
        if (string.IsNullOrWhiteSpace(selected))
        {
            output.WriteLine("Choose your provider: 1. Ollama  2. LM Studio (Windows GUI)  0. Exit");
            output.Write("Provider [1]: ");
            selected = input.ReadLine()?.Trim();
            if (selected is null or "0" || selected.Equals("exit", StringComparison.OrdinalIgnoreCase)) return null;
            if (selected == "") selected = "1";
        }
        if (selected is "1" || selected.Equals("Ollama", StringComparison.OrdinalIgnoreCase))
            return await new ConsoleSetup(input, output, new OllamaSetupServices(logger), logger, settingsPath).RunAsync();
        if (selected != "2" && !selected.Equals("LMStudio", StringComparison.OrdinalIgnoreCase))
            throw new ArgumentException("Select 1/Ollama or 2/LMStudio.");

        string path = settingsPath + ".lmstudio.json";
        ConsoleSettings preferences = new();
        if (File.Exists(path))
        {
            try { preferences = JsonSettings.Load<ConsoleSettings>(path, settings => settings.IsValid()); }
            catch (JsonException) { output.WriteLine("Saved LM Studio preferences are invalid; choose them again."); }
        }
        if (!LMStudioSetup.IsInstalled())
        {
            output.Write("Download and install the LM Studio Windows GUI? [y/N]: ");
            string? answer = input.ReadLine()?.Trim();
            if (!string.Equals(answer, "y", StringComparison.OrdinalIgnoreCase) && !string.Equals(answer, "yes", StringComparison.OrdinalIgnoreCase)) return null;
            await LMStudioSetup.InstallGuiAsync(logger);
        }
        await LMStudioSetup.EnsureServerAsync(logger);
        if (preferences.AgentName is null)
        {
            output.Write("Agent name [Lilith]: ");
            string? name = input.ReadLine()?.Trim();
            if (name is null || name.Equals("/exit", StringComparison.OrdinalIgnoreCase)) return null;
            if (name.Length > 80 || name.Any(char.IsControl)) throw new ArgumentException("Invalid agent name.");
            preferences = preferences with { AgentName = name.Length == 0 ? "Lilith" : name };
        }
        void Save() => JsonSettings.Save(path, preferences);
        Save();
        var models = await LMStudioSetup.ListModelsAsync();
        if (preferences.Model is null || !models.Any(m => m.Id == preferences.Model))
        {
            output.WriteLine("Downloaded LM Studio models:");
            for (int i = 0; i < models.Count; i++) output.WriteLine($"{i + 1}. {models[i].Name} ({models[i].Id})");
            output.Write("Choose a number or enter a catalog ID (e.g. ibm/granite-4-micro); 0 exits: ");
            string? model = input.ReadLine()?.Trim();
            if (model is null or "0" || model.Equals("exit", StringComparison.OrdinalIgnoreCase)) return null;
            if (int.TryParse(model, out int index))
            {
                if (index < 1 || index > models.Count) throw new ArgumentException("Invalid model number.");
                model = models[index - 1].Id;
            }
            if (model.Length > 200 || !RegexPatterns.ModelIdentifier().IsMatch(model)) throw new ArgumentException("Invalid LM Studio model identifier.");
            preferences = preferences with { Model = model };
            Save();
            if (!models.Any(m => m.Id == model))
            {
                output.Write($"Download LM Studio model '{model}'? [y/N]: ");
                string? answer = input.ReadLine()?.Trim();
                if (!string.Equals(answer, "y", StringComparison.OrdinalIgnoreCase) && !string.Equals(answer, "yes", StringComparison.OrdinalIgnoreCase)) return null;
                await LMStudioSetup.DownloadModelAsync(model, logger);
            }
        }
        return new LilithCredentials(preferences.Model!,
            $"You are {preferences.AgentName}, a helpful AI assistant. Greet the user warmly when the conversation begins.",
            preferences.AgentName!, Lilith.Core.Providers.ProviderKind.LMStudio);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <RootNamespace>Lilith.Agent</RootNamespace>
  </PropertyGroup>

  <ItemGroup>
    <ProjectReference Include="..\Core\Core.csproj" />
  </ItemGroup>

</Project>

1
2
3

using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("Lilith.RegressionChecks")]

1
2

global using Lilith.Core.Chat;
global using Lilith.Core.Extensions;

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

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", () => ChatCoreAsync("Please greet the user."));
        Logger.SystemWriteLine("", LogColors.White);
        IsBooted = true;
    }

    public async Task GreetAsync() => await ChatAsync("Please greet the user.");

    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

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)
    {
        using var operation = EnterOperation("Boot the agent before chatting.");
        await ChatCoreAsync(input, images);
    }

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

    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 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

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);
        return commands;
    }

    partial void RegisterScenarioCommands(ChatCommandRegistry commands);
    partial void RegisterWorkspaceCommands(ChatCommandRegistry commands);
    partial void RegisterScheduleCommands(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
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

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

namespace Lilith.Agent;

/// <summary>Agent client creation and logging helpers.</summary>
public static class LilithExtensions
{
    public static void EnsureSystemPromptSeeded(this Lilith agent)
    {
        if (agent.History.Count == 0 || !string.Equals(agent.History[0].Role, "system", StringComparison.OrdinalIgnoreCase))
            throw new InvalidOperationException("Chat history was not seeded with a system prompt.");
    }

    public static void EnsureSystemPromptContent(this Lilith agent)
    {
        agent.EnsureSystemPromptSeeded();
        if (string.IsNullOrWhiteSpace(agent.History[0].Content))
            throw new InvalidOperationException("System prompt content is missing.");
    }

    public static void EnsureContextInitialized(this Lilith agent)
    {
        if (agent.ContextMax <= 0)
            throw new InvalidOperationException("Model context window was not initialized.");
    }

    public static async Task<ProviderClient> CreateClient(this Lilith agent, bool startServerIfNotRunning = true) =>
        agent.Credentials.Provider switch
        {
            ProviderKind.Ollama => await OllamaClient.CreateClient(agent.Credentials.Model, agent.Credentials.SystemPrompt,
                agent.Logger, startServerIfNotRunning, agent.Credentials.AgentName),
            ProviderKind.LMStudio => await LMStudioClient.CreateClient(agent.Credentials.Model, agent.Credentials.SystemPrompt,
                agent.Logger, startServerIfNotRunning, agent.Credentials.AgentName),
            _ => throw new ArgumentOutOfRangeException(nameof(agent.Credentials.Provider))
        };

    public static void HistoryWriteLine(this Logger logger, string description = "", string color = LogColors.Gray) =>
        logger.WriteLine("History", description, color);

    public static void TokensWriteLine(this Logger logger, string description = "", string color = LogColors.Gray) =>
        logger.WriteLine("Tokens", description, color);

    public static void SystemWriteLine(this Logger logger, string description = "", string color = LogColors.Cyan) =>
        logger.WriteLine("System", description, color);

    public static void SystemPromptWriteLine(this Logger logger, string description = "", string color = LogColors.Cyan) =>
        logger.WriteLine("SYSTEM", description, color);

    public static void LogTokenCounts(this Lilith agent, TimeSpan? elapsed = null, string color = LogColors.Gray)
    {
        if (agent.History.Count < 2)
        {
            return;
        }

        int? promptTokens = agent.History[^2].Tokens;
        int? completionTokens = agent.History[^1].Tokens;
        if (promptTokens.HasValue || completionTokens.HasValue)
        {
            string elapsedText = elapsed is { } duration ? $"  elapsed: {duration.TotalSeconds:F2}s" : string.Empty;
            agent.Logger.TokensWriteLine($"prompt: {promptTokens ?? 0}  completion: {completionTokens ?? 0}  total: {(promptTokens ?? 0) + (completionTokens ?? 0)}{elapsedText}", color);
        }
    }
}

1
2
3
4
5
6
7

namespace Lilith.Agent;

public partial class Lilith
{
    public const string DefaultSystemPrompt = "You are Lilith, a helpful AI assistant. Greet the user warmly when the conversation begins.";

}

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

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 ProviderClient _llmclient = null!;
    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) =>
        _llmclient = ProviderFactory is { } factory ? await factory(startServerIfNotRunning) : await this.CreateClient(startServerIfNotRunning);

    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()
    {
        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

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

namespace Lilith.Agent;

public record LilithCredentials(
    string Model = "gemma4",
    string SystemPrompt = Lilith.DefaultSystemPrompt,
    string AgentName = "Lilith",
    ProviderKind Provider = ProviderKind.Ollama,
    KokoroTtsOptions? Tts = null);

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

namespace Lilith.Core;

/// <summary>
/// Root hub for agent addons. Create one instance and access <see cref="Logger"/>,
/// <see cref="OllamaClient"/>, and future services from the same object.
/// </summary>
public class Core(Action<LogEntry>? onLog = null) : IDisposable
{
    private static readonly Lazy<Core> Shared = new(() => new());
    private readonly object _sync = new();
    private OllamaClient? _client;
    private bool _ownsClient;
    private bool _disposed;

    /// <summary>Shared application core (optional).</summary>
    public static Core Default => Shared.Value;

    /// <summary>Subscribe-based logging (console, GUI, file, etc.).</summary>
    public Logger Logger { get; } = new(onLog);

    /// <summary>
    /// Ollama client addon. Assign after construction or via <see cref="UseOllamaAsync"/>.
    /// </summary>
    public OllamaClient? OllamaClient
    {
        get { lock (_sync) { ObjectDisposedException.ThrowIf(_disposed, this); return _client; } }
        set => Attach(value, owned: false);
    }

    /// <summary>Attach an Ollama client and return it for chaining.</summary>
    public OllamaClient UseOllama(OllamaClient ollamaClient)
    {
        Attach(ollamaClient ?? throw new ArgumentNullException(nameof(ollamaClient)), owned: false);
        return ollamaClient;
    }

    /// <summary>
    /// Creates and attaches a client for an already prepared model. Installation/download
    /// are explicit setup operations; this method only starts/checks the server and validates readiness.
    /// </summary>
    public async Task<OllamaClient> UseOllamaAsync(string model, string systemPrompt, bool startOllamaIfNotRunning = true)
    {
        lock (_sync) ObjectDisposedException.ThrowIf(_disposed, this);
        var client = await OllamaClient.CreateClient(model, systemPrompt, Logger, startOllamaIfNotRunning);
        try { Attach(client, owned: true); return client; }
        catch { client.Dispose(); throw; }
    }

    /// <summary>External attachments are borrowed; clients created by UseOllamaAsync are owned.</summary>
    internal void Attach(OllamaClient? client, bool owned)
    {
        lock (_sync)
        {
            ObjectDisposedException.ThrowIf(_disposed, this);
            if (ReferenceEquals(_client, client)) return;
            if (_ownsClient) _client?.Dispose();
            _client = client;
            _ownsClient = owned;
        }
    }

    public void Dispose()
    {
        lock (_sync)
        {
            if (_disposed) return;
            if (_ownsClient) _client?.Dispose();
            _disposed = true;
            _client = null;
            _ownsClient = false;
        }
        GC.SuppressFinalize(this);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <RootNamespace>Lilith.Core</RootNamespace>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="KokoroSharp.CPU" Version="0.8.4" />
  </ItemGroup>
</Project>

1
2
3
4
5

global using Lilith.Core.Logging;
global using Lilith.Core.Ollama;
global using Lilith.Core.Chat;
global using Lilith.Core.Extensions;
global using Lilith.Core.Providers;

1
2
3
4
5
6
7
8
9

using System.Text.Json.Serialization;

namespace Lilith.Core.Chat;

public record ChatChunk(
    [property: JsonPropertyName("message")] ChatMessage? Message,
    [property: JsonPropertyName("done")] bool Done,
    [property: JsonPropertyName("prompt_eval_count")] int? PromptTokens,
    [property: JsonPropertyName("eval_count")] int? CompletionTokens);

1
2
3
4
5
6
7
8
9

using System.Text.Json.Serialization;

namespace Lilith.Core.Chat;

public class ChatHistory : List<ChatMessage>
{
    public void Add(string role, string content, int? tokens = null) =>
        Add(new ChatMessage(role, content, Tokens: tokens));
}

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

using System.Text.RegularExpressions;
using System.Xml.Linq;

namespace Lilith.Core.Chat;

public class ChatHistoryStore
{
    public string CurrentSessionId { get; private set; } = NewSessionId();
    public string RootDirectory { get; }

    public ChatHistoryStore() : this(null)
    {
    }

    /// <param name="rootDirectoryOverride">Optional folder for tests or custom deployments.</param>
    public ChatHistoryStore(string? rootDirectoryOverride)
    {
        if (!string.IsNullOrWhiteSpace(rootDirectoryOverride))
        {
            RootDirectory = rootDirectoryOverride;
            return;
        }

        string? envRoot = Environment.GetEnvironmentVariable("AGENT_CORE_CHAT_HISTORY_ROOT");
        if (!string.IsNullOrWhiteSpace(envRoot))
        {
            RootDirectory = envRoot;
            return;
        }

        string appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
        if (string.IsNullOrWhiteSpace(appData))
        {
            appData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
        }

        if (string.IsNullOrWhiteSpace(appData))
        {
            appData = AppContext.BaseDirectory;
        }

        RootDirectory = Path.Combine(appData, "AgentCore", DetectVersionLabel(), "ChatHistory");
    }

    public void StartNewSession() => CurrentSessionId = NewSessionId();

    public void UseSession(string id)
    {
        if (!string.IsNullOrWhiteSpace(id))
        {
            CurrentSessionId = SanitizeId(id);
        }
    }

    public string SaveSession(string model, IEnumerable<ChatMessage> history) =>
        SaveSession(CurrentSessionId, model, history);

    public string SaveSession(string? sessionId, string model, IEnumerable<ChatMessage> history)
    {
        Directory.CreateDirectory(RootDirectory);

        string id = string.IsNullOrWhiteSpace(sessionId) ? NewSessionId() : SanitizeId(sessionId);
        string path = SessionPath(id);
        DateTimeOffset now = DateTimeOffset.Now;
        DateTimeOffset createdAt = ReadCreatedAt(path) ?? now;
        var messages = history.Select(m => m.ToSavedMessage()).ToList();

        var doc = new XDocument(
            new XElement("chatSession",
                new XAttribute("id", id),
                new XAttribute("title", MakeTitle(messages)),
                new XAttribute("model", model),
                new XAttribute("createdAt", createdAt.ToString("O")),
                new XAttribute("updatedAt", now.ToString("O")),
                new XElement("messages",
                    messages.Select(m =>
                        new XElement("message",
                            new XAttribute("role", m.Role),
                            m.Tokens.HasValue ? new XAttribute("tokens", m.Tokens.Value) : null,
                            new XElement("content", m.Content),
                            m.Images is { Count: > 0 }
                                ? new XElement("images", m.Images.Select(i => new XElement("image", i)))
                                : null)))));

        AtomicFile.Write(path, doc.Save);
        CurrentSessionId = id;
        return id;
    }

    public IReadOnlyList<ChatSessionSummary> ListSessions()
    {
        if (!Directory.Exists(RootDirectory))
        {
            return [];
        }

        return Directory.EnumerateFiles(RootDirectory, "*.xml")
            .Select(ReadSummary)
            .Where(s => s is not null)
            .Select(s => s!)
            .OrderByDescending(s => s.UpdatedAt)
            .ToList();
    }

    public SavedChatSession? LoadSession(string id)
    {
        string path = SessionPath(SanitizeId(id));
        if (!File.Exists(path))
        {
            return null;
        }

        var session = ReadSession(path, SanitizeId(id));
        CurrentSessionId = session.Id;
        return session;
    }

    private static SavedChatSession ReadSession(string path, string id)
    {
        XDocument doc = XDocument.Load(path);
        XElement root = doc.Root ?? throw new InvalidDataException("Chat XML has no root.");
        if (root.Name != "chatSession" || root.Element("messages") is null ||
            ((string?)root.Attribute("id") is { } embedded && embedded != id))
            throw new InvalidDataException("Invalid chat session structure or identity.");
        var session = new SavedChatSession
        {
            Id = id,
            Title = (string?)root.Attribute("title") ?? "New chat",
            Model = (string?)root.Attribute("model") ?? string.Empty,
            CreatedAt = ParseDate((string?)root.Attribute("createdAt")) ?? DateTimeOffset.Now,
            UpdatedAt = ParseDate((string?)root.Attribute("updatedAt")) ?? DateTimeOffset.Now,
            Messages = root.Element("messages")?.Elements("message").Select(ReadMessage).ToList() ?? []
        };
        if (session.Messages.Count == 0) throw new InvalidDataException("Chat has no messages.");
        for (int i = 0; i < session.Messages.Count; i++)
        {
            var message = session.Messages[i];
            if (message.Role is not ("system" or "user" or "assistant") || message.Tokens is < 0 ||
                (message.Role == "system" && (i != 0 || string.IsNullOrWhiteSpace(message.Content))))
                throw new InvalidDataException("Chat contains invalid messages.");
        }
        return session;
    }

    private string SessionPath(string id) => Path.Combine(RootDirectory, SanitizeId(id) + ".xml");

    private static SavedChatMessage ReadMessage(XElement element)
    {
        int? tokens = null;
        if (element.Attribute("tokens") is { } attribute)
        {
            if (!int.TryParse(attribute.Value, out int value)) throw new InvalidDataException("Invalid token count.");
            tokens = value;
        }
        var images = element.Element("images")?.Elements("image")
            .Select(i => i.Value)
            .Where(i => !string.IsNullOrWhiteSpace(i))
            .ToList();

        return new SavedChatMessage
        {
            Role = (string?)element.Attribute("role") ?? string.Empty,
            Content = element.Element("content")?.Value ?? string.Empty,
            Tokens = tokens,
            Images = images is { Count: > 0 } ? images : null
        };
    }

    private static ChatSessionSummary? ReadSummary(string path)
    {
        try
        {
            string id = Path.GetFileNameWithoutExtension(path);
            var session = ReadSession(path, id);
            return new ChatSessionSummary(
                id,
                session.Title, session.CreatedAt, session.UpdatedAt, session.Messages.Count, session.Model);
        }
        catch
        {
            return null;
        }
    }

    private static DateTimeOffset? ReadCreatedAt(string path)
    {
        if (!File.Exists(path))
        {
            return null;
        }

        try
        {
            XDocument doc = XDocument.Load(path);
            return ParseDate((string?)doc.Root?.Attribute("createdAt"));
        }
        catch
        {
            return null;
        }
    }

    private static DateTimeOffset? ParseDate(string? value) =>
        DateTimeOffset.TryParse(value, out var parsed) ? parsed : null;

    private static string MakeTitle(IReadOnlyList<SavedChatMessage> messages)
    {
        string? firstUser = messages
            .Where(m => m.Role.Equals("user", StringComparison.OrdinalIgnoreCase))
            .Select(m => m.Content.Trim())
            .FirstOrDefault(m => !string.IsNullOrWhiteSpace(m) &&
                !m.StartsWith("Please greet", StringComparison.OrdinalIgnoreCase) &&
                !m.Equals("hello", StringComparison.OrdinalIgnoreCase));

        if (string.IsNullOrWhiteSpace(firstUser))
        {
            firstUser = messages.FirstOrDefault(m => m.Role != "system" && !string.IsNullOrWhiteSpace(m.Content))?.Content.Trim();
        }

        if (string.IsNullOrWhiteSpace(firstUser))
        {
            return "New chat";
        }

        firstUser = RegexPatterns.Whitespace().Replace(firstUser, " ");
        return firstUser.Length <= 60 ? firstUser : firstUser[..57] + "...";
    }

    private static string DetectVersionLabel()
    {
        foreach (string source in new[] { AppContext.BaseDirectory, Environment.CurrentDirectory })
        {
            var match = RegexPatterns.VersionLabel().Match(source);
            if (match.Success)
            {
                return RegexPatterns.Whitespace().Replace(match.Value, " ");
            }
        }

        return "Default";
    }

    private static string NewSessionId() => DateTimeOffset.UtcNow.ToString("yyyyMMddHHmmssfff") + "-" + Guid.NewGuid().ToString("N");

    private static string SanitizeId(string id) =>
        string.Concat(id.Where(c => char.IsLetterOrDigit(c) || c is '-' or '_'));
}

1
2
3
4
5
6
7
8
9

using System.Text.Json.Serialization;

namespace Lilith.Core.Chat;

public record ChatMessage(
    [property: JsonPropertyName("role")] string Role,
    [property: JsonPropertyName("content")] string Content,
    [property: JsonPropertyName("images"), JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)] List<string>? Images = null,
    [property: JsonIgnore] int? Tokens = null);

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

namespace Lilith.Core.Chat;

public static class ChatMessageExtensions
{
    public static ChatMessage Snapshot(this ChatMessage message) =>
        message with { Images = message.Images is null ? null : [.. message.Images] };

    public static SavedChatMessage ToSavedMessage(this ChatMessage message) => new()
    {
        Role = message.Role,
        Content = message.Content ?? string.Empty,
        Tokens = message.Tokens,
        Images = message.Images is { Count: > 0 } ? [.. message.Images] : null
    };

    public static ChatMessage ToChatMessage(this SavedChatMessage message) =>
        new(message.Role, message.Content, message.Images is null ? null : [.. message.Images], message.Tokens);
}

1
2
3
4
5
6

using System.Text.Json.Serialization;

namespace Lilith.Core.Chat;

internal record ChatOptions(
    [property: JsonPropertyName("num_ctx")] int NumCtx);

1
2
3
4
5
6
7
8
9

using System.Text.Json.Serialization;

namespace Lilith.Core.Chat;

internal record ChatRequest(
    [property: JsonPropertyName("model")] string Model,
    [property: JsonPropertyName("messages")] List<ChatMessage> Messages,
    [property: JsonPropertyName("stream")] bool Stream,
    [property: JsonPropertyName("options")] ChatOptions? Options = null);

1
2
3
4
5
6
7
8
9
10
11
12

using System.Text.RegularExpressions;
using System.Xml.Linq;

namespace Lilith.Core.Chat;

public record ChatSessionSummary(
    string Id,
    string Title,
    DateTimeOffset CreatedAt,
    DateTimeOffset UpdatedAt,
    int MessageCount,
    string Model);

1
2
3
4
5
6
7
8
9
10
11
12

using System.Text.RegularExpressions;
using System.Xml.Linq;

namespace Lilith.Core.Chat;

public class SavedChatMessage
{
    public string Role { get; set; } = string.Empty;
    public string Content { get; set; } = string.Empty;
    public int? Tokens { get; set; }
    public List<string>? Images { get; set; }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

using System.Text.RegularExpressions;
using System.Xml.Linq;

namespace Lilith.Core.Chat;

public class SavedChatSession
{
    public string Id { get; set; } = string.Empty;
    public string Title { get; set; } = "New chat";
    public DateTimeOffset CreatedAt { get; set; } = DateTimeOffset.Now;
    public DateTimeOffset UpdatedAt { get; set; } = DateTimeOffset.Now;
    public string Model { get; set; } = string.Empty;
    public List<SavedChatMessage> Messages { get; set; } = [];
}

1
2
3
4
5
6

using System.Text.Json.Serialization;

namespace Lilith.Core.Chat;

internal record ShowModelRequest(
    [property: JsonPropertyName("model")] string Model);

1
2
3
4
5
6

using System.Text.Json.Serialization;

namespace Lilith.Core.Chat;

internal record ShowModelResponse(
    [property: JsonPropertyName("model_info")] Dictionary<string, System.Text.Json.JsonElement>? ModelInfo);

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.RegularExpressions;

namespace Lilith.Core.Commands;

public sealed record ChatCommandContext(string Arguments, CancellationToken CancellationToken)
{
    public void RequireNoArguments() { if (Arguments.Length > 0) throw new ArgumentException("This command takes no arguments."); }
}
public sealed record ChatCommandResult(bool Handled, string? Output = null, bool ExitRequested = false);
public sealed record ChatCommandInfo(string Name, string Description);

/// <summary>Host commands are dispatched locally, never sent to the model as chat.</summary>
public sealed class ChatCommandRegistry
{
    private readonly object _sync = new();
    private readonly Dictionary<string, (ChatCommandInfo Info, Func<ChatCommandContext, Task<ChatCommandResult>> Handler)> _commands = new(StringComparer.OrdinalIgnoreCase);
    public IReadOnlyList<ChatCommandInfo> List() { lock (_sync) return _commands.Values.Select(c => c.Info).OrderBy(c => c.Name, StringComparer.Ordinal).ToArray(); }
    public string Help() => string.Join("\n", List().Select(c => $"/{c.Name} - {c.Description}"));

    public void Register(string name, string description, Func<ChatCommandContext, string?> handler)
    {
        ArgumentNullException.ThrowIfNull(handler);
        RegisterAsync(name, description, context => Task.FromResult(new ChatCommandResult(true, handler(context))));
    }
    public void RegisterAsync(string name, string description, Func<ChatCommandContext, Task<ChatCommandResult>> handler)
    {
        ArgumentNullException.ThrowIfNull(handler);
        name = name.TrimStart('/');
        if (!Regex.IsMatch(name, "^[a-zA-Z][a-zA-Z0-9_-]{0,63}$") || string.IsNullOrWhiteSpace(description)) throw new ArgumentException("Supply a command name and description.");
        lock (_sync)
            if (!_commands.TryAdd(name, (new(name.ToLowerInvariant(), description), handler))) throw new ArgumentException("Command already registered: " + name);
    }
    public async Task<ChatCommandResult> ExecuteAsync(string input, CancellationToken cancellationToken = default)
    {
        cancellationToken.ThrowIfCancellationRequested();
        string text = input.TrimStart();
        if (!text.StartsWith('/')) return new(false);
        int end = 1;
        while (end < text.Length && !char.IsWhiteSpace(text[end])) end++;
        string name = text[1..end];
        Func<ChatCommandContext, Task<ChatCommandResult>>? handler;
        lock (_sync) handler = _commands.TryGetValue(name, out var command) ? command.Handler : null;
        if (handler is null) return new(true, $"Unknown command /{name}. Use /help.");
        var result = await handler(new(text[end..].Trim(), cancellationToken));
        return result with { Handled = true };
    }
}

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

namespace Lilith.Core.Extensions;

public static class AtomicFile
{
    private static readonly object[] Gates = [.. Enumerable.Range(0, 64).Select(_ => new object())];

    public static void Write(string path, Action<string> write)
    {
        path = Path.GetFullPath(path);
        lock (Gates[(uint)StringComparer.OrdinalIgnoreCase.GetHashCode(path) % Gates.Length])
        {
            Directory.CreateDirectory(Path.GetDirectoryName(path)!);
            string temporary = path + "." + Guid.NewGuid().ToString("N") + ".tmp";
            try
            {
                write(temporary);
                // Windows readers/other processes may briefly hold the destination without delete sharing.
                for (int attempt = 0; ; attempt++)
                {
                    try { File.Move(temporary, path, overwrite: true); break; }
                    catch (Exception ex) when (attempt < 10 && ex is IOException or UnauthorizedAccessException)
                    { Thread.Sleep(20); }
                }
            }
            finally { if (File.Exists(temporary)) File.Delete(temporary); }
        }
    }
}

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.Diagnostics;

namespace Lilith.Core.Extensions;

public static class BootTimingExtensions
{
    public static async Task<T> TimeStageAsync<T>(this Logger logger, string stage, Func<Task<T>> action)
    {
        var timer = Stopwatch.StartNew();
        bool succeeded = false;
        try
        {
            T result = await action();
            succeeded = true;
            return result;
        }
        finally
        {
            timer.Stop();
            logger.WriteLine("Boot", $"{stage} {(succeeded ? "finished" : "failed")} — elapsed {timer.Elapsed.TotalSeconds:F2}s",
                succeeded ? LogColors.Gray : LogColors.Red);
        }
    }

    public static Task TimeStageAsync(this Logger logger, string stage, Func<Task> action) =>
        logger.TimeStageAsync(stage, async () => { await action(); return true; });
}

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

using System.Net.Http.Json;
using System.Text.Json;

namespace Lilith.Core.Extensions;

public static class HttpExtensions
{
    public static HttpRequestMessage JsonRequest<T>(string url, T body) =>
        new(HttpMethod.Post, url) { Content = JsonContent.Create(body) };

    public static T? Deserialize<T>(this string json) =>
        JsonSerializer.Deserialize<T>(json);

    public static async Task<T?> SendJsonAsync<T>(this HttpClient http, HttpRequestMessage request,
        CancellationToken ct = default)
    {
        using var response = await http.SendAsync(request, ct);
        response.EnsureSuccessStatusCode();
        return JsonSerializer.Deserialize<T>(await response.Content.ReadAsStringAsync(ct));
    }

    /// <summary>The caller owns the returned document; the request remains caller-owned.</summary>
    public static async Task<JsonDocument> SendJsonDocumentAsync(this HttpClient http, HttpRequestMessage request,
        CancellationToken ct = default)
    {
        using var response = await http.SendAsync(request, ct);
        response.EnsureSuccessStatusCode();
        return JsonDocument.Parse(await response.Content.ReadAsStringAsync(ct));
    }

    public static async Task<bool> IsReachableAsync(this HttpClient http, string url)
    {
        try
        {
            using HttpResponseMessage response = await http.GetAsync(url);
            return response.IsSuccessStatusCode;
        }
        catch (Exception ex) when (ex is HttpRequestException or TaskCanceledException)
        {
            return false;
        }
    }
}

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

using System.Text.Json;

namespace Lilith.Core.Extensions;

public static class JsonSettings
{
    public static T Load<T>(string path, Func<T, bool> valid) where T : class
    {
        var value = JsonSerializer.Deserialize<T>(File.ReadAllText(path));
        if (value is null || !valid(value)) throw new JsonException("Saved preferences contain invalid values.");
        return value;
    }

    public static void Save<T>(string path, T value) => AtomicFile.Write(path, temporary =>
        File.WriteAllText(temporary, JsonSerializer.Serialize(value, new JsonSerializerOptions { WriteIndented = true })));
}

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

using System.Diagnostics;

namespace Lilith.Core.Extensions;

public static class ProcessExtensions
{
    /// <summary>On timeout, terminates the process tree and waits before releasing ownership.</summary>
    public static async Task WaitForExitOrKillAsync(this Process process, TimeSpan timeout, string message)
    {
        try { await process.WaitForExitAsync().WaitAsync(timeout); }
        catch (TimeoutException)
        {
            if (!process.HasExited) process.Kill(entireProcessTree: true);
            await process.WaitForExitAsync();
            throw new TimeoutException(message);
        }
    }
}

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 System.Text.RegularExpressions;

namespace Lilith.Core.Extensions;

/// <summary>Shared fixed patterns compiled by the regex source generator.</summary>
public static partial class RegexPatterns
{
    [GeneratedRegex(@"\S+")]
    public static partial Regex Words();

    [GeneratedRegex(@"\s+")]
    public static partial Regex Whitespace();

    [GeneratedRegex(@"Version\s+\d+", RegexOptions.IgnoreCase)]
    public static partial Regex VersionLabel();

    [GeneratedRegex(@"^\s*[#\s]*\d+(?:\.\d+)?%\s*$")]
    public static partial Regex InstallerProgress();

    [GeneratedRegex(@"\x1b\[[0-?]*[ -/]*[@-~]")]
    public static partial Regex AnsiEscape();

    [GeneratedRegex(@"(?<![\d.])(\d+(?:\.\d+)?)%")]
    public static partial Regex DownloadPercentage();

    [GeneratedRegex(@"^[A-Za-z0-9][A-Za-z0-9._:/@-]*$")]
    public static partial Regex ModelIdentifier();

    [GeneratedRegex(@"^[A-Za-z0-9][A-Za-z0-9._:/-]*$")]
    public static partial Regex OllamaModelIdentifier();
}

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

namespace Lilith.Core.Extensions;

public static class SemaphoreExtensions
{
    public static IDisposable EnterOrThrow(this SemaphoreSlim gate, string message)
    {
        if (!gate.Wait(0)) throw new InvalidOperationException(message);
        return new SemaphoreLease(gate);
    }

    public static async Task<IDisposable> EnterAsync(this SemaphoreSlim gate, CancellationToken ct = default)
    {
        await gate.WaitAsync(ct);
        return new SemaphoreLease(gate);
    }
}

1
2
3
4
5
6
7

namespace Lilith.Core.Extensions;

internal sealed class SemaphoreLease(SemaphoreSlim gate) : IDisposable
{
    private SemaphoreSlim? _gate = gate;
    public void Dispose() => Interlocked.Exchange(ref _gate, null)?.Release();
}

1
2
3
4
5
6
7
8
9
10
11

namespace Lilith.Core.Extensions;

public static class TextReaderExtensions
{
    public static async Task<bool> ConfirmAsync(this TextReader input, TextWriter output, string prompt,
        CancellationToken ct = default)
    {
        await output.WriteAsync(prompt);
        return string.Equals((await input.ReadLineAsync(ct))?.Trim(), "y", StringComparison.OrdinalIgnoreCase);
    }
}

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

namespace Lilith.Core.Kokoro;

/// <summary>Bounds callers' waits while retaining ownership until native work actually ends.</summary>
internal sealed class AsyncResourceOwner(Action cleanup, TimeSpan timeout, TimeSpan shutdownTimeout)
{
    private readonly object _sync = new();
    private readonly CancellationTokenSource _lifetime = new();
    private readonly HashSet<Task> _work = [];
    private bool _closing;
    private bool _faulted;
    private Task? _dispose;

    public bool IsClosing { get { lock (_sync) return _closing; } }
    public void WhileOpen(Action action) { lock (_sync) { if (!_closing) action(); } }

    public Task RunAsync(Func<CancellationToken, Task> action, CancellationToken ct = default)
    {
        Task work;
        lock (_sync)
        {
            ObjectDisposedException.ThrowIf(_closing, this);
            if (_faulted) throw new InvalidOperationException("Speech engine timed out; restart the agent before retrying speech.");
            ct.ThrowIfCancellationRequested();
            work = Task.Run(async () =>
            {
                using var linked = CancellationTokenSource.CreateLinkedTokenSource(ct, _lifetime.Token);
                await action(linked.Token);
            });
            _work.Add(work);
        }
        _ = work.ContinueWith(completed =>
        {
            _ = completed.Exception; // Observe errors even if the caller stopped waiting.
            lock (_sync) _work.Remove(completed);
        }, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
        return WaitAsync(work, ct);
    }

    private async Task WaitAsync(Task work, CancellationToken ct)
    {
        try { await work.WaitAsync(timeout, ct); }
        catch (TimeoutException)
        {
            lock (_sync)
            {
                _faulted = true;
                if (!_closing) _lifetime.Cancel();
            }
            throw new TimeoutException("Kokoro operation timed out. Native work still owns its resources until it finishes.");
        }
    }

    public Task DisposeAsync()
    {
        lock (_sync)
        {
            if (_dispose is not null) return _dispose;
            _closing = true;
            _lifetime.Cancel();
            Task[] pending = [.. _work];
            _dispose = DisposeCoreAsync(pending);
            return _dispose;
        }
    }

    private async Task DisposeCoreAsync(Task[] pending)
    {
        var cleanupTask = Task.Run(async () =>
        {
            try { await Task.WhenAll(pending); }
            catch { /* Completion, including failure, releases ownership. */ }
            finally { try { cleanup(); } finally { _lifetime.Dispose(); } }
        });
        // If native work is stuck, cleanup remains attached to it and never frees live resources.
        try { await cleanupTask.WaitAsync(shutdownTimeout); }
        catch (TimeoutException)
        {
            _ = cleanupTask.ContinueWith(task => _ = task.Exception, TaskScheduler.Default);
        }
    }
}

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 Microsoft.ML.OnnxRuntime;

namespace Lilith.Core.Kokoro;

internal static class KokoroModelFiles
{
    public static async Task<bool> IsUsableAsync(string path)
    {
        if (!File.Exists(path) || new FileInfo(path).Length == 0) return false;
        try
        {
            return await Task.Run(() =>
            {
                using var session = new InferenceSession(path);
                return session.InputMetadata.ContainsKey("tokens") && session.InputMetadata.ContainsKey("style") &&
                    session.InputMetadata.ContainsKey("speed") && session.OutputMetadata.Count > 0;
            });
        }
        // ONNX invalid protobuf (7) or invalid graph (10) identifies model data damage.
        // Other runtime failures propagate: they must not quarantine a usable model.
        catch (OnnxRuntimeException ex) when (ex.Message.StartsWith("[ErrorCode:InvalidProtobuf]", StringComparison.Ordinal) ||
            ex.Message.StartsWith("[ErrorCode:InvalidGraph]", StringComparison.Ordinal)) { return false; }
    }

    public static void Quarantine(string path)
    {
        if (File.Exists(path)) File.Move(path, path + ".invalid-" + Guid.NewGuid().ToString("N"));
    }
}

1
2
3
4
5
6
7
8
9
10

using KokoroSharp.Processing;
using System.Text.RegularExpressions;
using KokoroSharp;
using KokoroSharp.Core;
using Lilith.Core.Logging;
using NAudio.Wave;

namespace Lilith.Core.Kokoro;

public sealed record KokoroNarration(byte[] Audio, KokoroWord[] Words, string TimingSource = "phoneme");

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

using System.Text.RegularExpressions;

namespace Lilith.Core.Kokoro;

internal static partial class KokoroRegex
{
    [GeneratedRegex(@"(?:`{3,}|~{3,})[\s\S]*?(?:(?:`{3,}|~{3,})|\z)", RegexOptions.CultureInvariant)]
    public static partial Regex CodeFence();

    [GeneratedRegex(@"!?\[(?<label>[^\]]*)\]\((?:[^()\r\n]|\([^()\r\n]*\))*\)", RegexOptions.CultureInvariant)]
    public static partial Regex MarkdownLink();

    [GeneratedRegex(@"https?://[^\s<>]+", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)]
    public static partial Regex WebUrl();

    [GeneratedRegex(@"(?<![\w\\])(?<mark>\*{1,3}|_{1,3})(?<value>\S(?:[^\r\n]*?\S)?)\k<mark>(?!\w)", RegexOptions.CultureInvariant)]
    public static partial Regex Emphasis();

    [GeneratedRegex(@"~~(?<value>[^\r\n]*?)~~", RegexOptions.CultureInvariant)]
    public static partial Regex StrikeThrough();

    [GeneratedRegex(@"^(?:[-*+]|\d+[.)])[ \t]+", RegexOptions.CultureInvariant)]
    public static partial Regex ListMarker();

    [GeneratedRegex(@"^#{1,6}[ \t]+", RegexOptions.CultureInvariant)]
    public static partial Regex HeadingMarker();

    [GeneratedRegex(@"^(?:>[ \t]*)+", RegexOptions.CultureInvariant)]
    public static partial Regex QuoteMarker();

    [GeneratedRegex(@"\s+", RegexOptions.CultureInvariant)]
    public static partial Regex Whitespace();

    [GeneratedRegex(@"([!?])\1+", RegexOptions.CultureInvariant)]
    public static partial Regex RepeatedPunctuation();

    [GeneratedRegex(@"[ \t]+([,.;:!?])", RegexOptions.CultureInvariant)]
    public static partial Regex SpaceBeforePunctuation();
}