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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

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

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

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

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

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

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
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278

using System.Text.RegularExpressions;
using System.Xml.Linq;
using System.Text.Json;
using Lilith.Core.Tools;

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.ToolCalls is { Count: > 0 } ? new XElement("toolCalls", JsonSerializer.Serialize(m.ToolCalls)) : null,
                            m.ToolName is not null ? new XElement("toolName", m.ToolName) : null,
                            m.ToolCallId is not null ? new XElement("toolCallId", m.ToolCallId) : null,
                            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.");
        var pending = new Queue<ToolCall>();
        for (int i = 0; i < session.Messages.Count; i++)
        {
            var message = session.Messages[i];
            if (message.Role is not ("system" or "user" or "assistant" or "tool") || message.Tokens is < 0 ||
                (message.Role == "system" && (i != 0 || string.IsNullOrWhiteSpace(message.Content))))
                throw new InvalidDataException("Chat contains invalid messages.");
            if (message.Role == "tool")
            {
                if (!pending.TryDequeue(out var call) || message.ToolName != call.Function.Name || message.ToolCallId != call.Id ||
                    message.ToolCalls is { Count: > 0 })
                    throw new InvalidDataException("Chat contains an unmatched tool result.");
            }
            else
            {
                if (pending.Count != 0 || message.ToolName is not null || message.ToolCallId is not null)
                    throw new InvalidDataException("Chat contains an incomplete tool exchange.");
                if (message.ToolCalls is { Count: > 0 } calls)
                {
                    if (message.Role != "assistant") throw new InvalidDataException("Only assistants may call tools.");
                    foreach (var call in calls)
                    {
                        if (call?.Function is null || string.IsNullOrWhiteSpace(call.Function.Name) || call.Function.Arguments.ValueKind != JsonValueKind.Object)
                            throw new InvalidDataException("Invalid saved tool call.");
                        pending.Enqueue(call);
                    }
                }
            }
        }
        if (pending.Count != 0) throw new InvalidDataException("Chat ends with pending tool calls.");
        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,
            ToolCalls = element.Element("toolCalls") is { } calls ? JsonSerializer.Deserialize<List<ToolCall>>(calls.Value) : null,
            ToolName = element.Element("toolName")?.Value,
            ToolCallId = element.Element("toolCallId")?.Value
        };
    }

    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
10
11
12

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,
    [property: JsonPropertyName("tool_calls"), JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)] List<Lilith.Core.Tools.ToolCall>? ToolCalls = null,
    [property: JsonPropertyName("tool_name"), JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)] string? ToolName = null,
    [property: JsonIgnore] string? ToolCallId = 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

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],
            ToolCalls = message.ToolCalls?.Select(c => c with { Function = c.Function with { Arguments = c.Function.Arguments.Clone() } }).ToList()
        };

    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,
        ToolCalls = message.Snapshot().ToolCalls, ToolName = message.ToolName, ToolCallId = message.ToolCallId
    };

    public static ChatMessage ToChatMessage(this SavedChatMessage message) =>
        new ChatMessage(message.Role, message.Content, message.Images, message.Tokens,
            message.ToolCalls, message.ToolName, message.ToolCallId).Snapshot();
}

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
10

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,
    [property: JsonPropertyName("tools"), JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)] object[]? Tools = 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
13
14
15

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; }
    public List<Lilith.Core.Tools.ToolCall>? ToolCalls { get; set; }
    public string? ToolName { get; set; }
    public string? ToolCallId { 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;
        }
    }
}