Read the whole
conversation.

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

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