added basic flow and prompting

services/illmservice.cs

@@ -8,5 +8,7 @@ namespace finder2e_foundry_converter.Services
     {
         Task<List<string>> GetModelsAsync(string baseUrl);
         Task<string> GenerateResponseAsync(string baseUrl, string model, string text, List<string> imagePaths);
+        // Ask a single prompt and return assistant's textual response (no streaming)
+        Task<string> AskAsync(string baseUrl, string model, string prompt, List<string> imagePaths);
     }
 }

services/lmstudioservice.cs

@@ -93,6 +93,42 @@ namespace finder2e_foundry_converter.Services
             }
         }
 
+        public async Task<string> AskAsync(string baseUrl, string model, string prompt, List<string> imagePaths)
+        {
+            // LM Studio expects messages content; reuse the same structure but with a simple text message
+            try
+            {
+                var requestBody = new
+                {
+                    model = model,
+                    messages = new[]
+                    {
+                        new { role = "user", content = new[] { new { type = "text", text = prompt } } }
+                    }
+                };
+
+                var response = await _httpClient.PostAsJsonAsync($"{baseUrl.TrimEnd('/')}/v1/chat/completions", requestBody);
+                var body = await response.Content.ReadAsStringAsync();
+
+                using var doc = JsonDocument.Parse(body);
+                if (doc.RootElement.TryGetProperty("error", out var error))
+                {
+                    return $"Error: {error.GetProperty("message").GetString()}";
+                }
+
+                if (doc.RootElement.TryGetProperty("choices", out var choices) && choices.GetArrayLength() > 0)
+                {
+                    return choices[0].GetProperty("message").GetProperty("content").GetString() ?? "No content returned";
+                }
+
+                return "No response choices returned.";
+            }
+            catch (Exception ex)
+            {
+                return $"Error: {ex.Message}";
+            }
+        }
+
         private class ModelsResponse
         {
             [JsonPropertyName("data")]

services/ollamaservice.cs

@@ -72,6 +72,12 @@ namespace finder2e_foundry_converter.Services
             }
         }
 
+        public async Task<string> AskAsync(string baseUrl, string model, string prompt, List<string> imagePaths)
+        {
+            // Reuse GenerateResponseAsync semantics for single-shot prompts
+            return await GenerateResponseAsync(baseUrl, model, prompt, imagePaths);
+        }
+
         private class OllamaModelsResponse
         {
             [JsonPropertyName("models")]

viewmodels/mainwindowviewmodel.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.ObjectModel;
 using System.IO;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using System.Windows.Input;
@@ -51,12 +52,14 @@ namespace finder2e_foundry_converter.ViewModels
         public ObservableCollection<string> Providers { get; } = new() { "LM Studio", "Ollama" };
 
         [ObservableProperty]
+        [NotifyPropertyChangedFor(nameof(CanGenerate))]
         private string? _selectedModel;
  
         public ObservableCollection<string> Models { get; } = new();
  
         [ObservableProperty]
         [NotifyPropertyChangedFor(nameof(IsNpcSelected))]
+        [NotifyPropertyChangedFor(nameof(CanGenerate))]
         private string? _selectedCategory;
 
         public ObservableCollection<string> Categories { get; } = new() { "NPCs" };
@@ -66,6 +69,11 @@ namespace finder2e_foundry_converter.ViewModels
 
         public ObservableCollection<int> Levels { get; } = new();
  
+        [ObservableProperty]
+        private string _selectedSystem = "pf2e";
+
+        public ObservableCollection<string> Systems { get; } = new() { "pf2e", "sf2e" };
+
         [ObservableProperty]
         private string _name = string.Empty;
  
@@ -85,6 +93,22 @@ namespace finder2e_foundry_converter.ViewModels
         [ObservableProperty]
         private string _errorText = string.Empty;
 
+        [ObservableProperty]
+        private bool _isGenerating = false;
+
+        [ObservableProperty]
+        private double _progress = 0.0;
+
+        [ObservableProperty]
+        private string _generatedNpcJson = string.Empty;
+
+        [ObservableProperty]
+        private string _temporaryNpcPath = string.Empty;
+
+        // Holds the raw TOML prompts and retry prefix
+        private Dictionary<string, (string question, string constraints)> _npcPrompts = new();
+        private string _npcRetryPrefix = "";
+
         public MainWindowViewModel()
         {
             // Load saved preferences would go here if we had a settings service
@@ -95,6 +119,12 @@ namespace finder2e_foundry_converter.ViewModels
             _ = StartModelRefreshLoop();
         }
 
+        public bool CanGenerate => !IsGenerating && !string.IsNullOrEmpty(SelectedModel);
+
+        partial void OnIsGeneratingChanged(bool value)
+        {
+            OnPropertyChanged(nameof(CanGenerate));
+        }
         partial void OnSelectedProviderChanged(string value)
         {
             Models.Clear();
@@ -135,32 +165,196 @@ namespace finder2e_foundry_converter.ViewModels
             }
         }
 
-        [ObservableProperty]
-        private string _generatedNpcJson = string.Empty;
-
-        [ObservableProperty]
-        private string _temporaryNpcPath = string.Empty;
 
         [RelayCommand]
         private async Task Generate()
         {
-            // Minimal validation
             if (string.IsNullOrEmpty(SelectedModel))
             {
                 StatusMessage = "Please select a model first.";
                 return;
             }
 
-            StatusMessage = "Generating NPC from template...";
+            IsGenerating = true;
+            Progress = 0.0;
+            GeneratedNpcJson = string.Empty;
+            StatusMessage = "Starting NPC generation...";
 
             try
             {
-                // Load template JSON
+                // Load the prompts from llmflow/npc.toml
                 var cwd = Directory.GetCurrentDirectory();
+                var tomlPath = Path.Combine(cwd, "llmflow", "npc.toml");
+                _npcPrompts.Clear();
+                _npcRetryPrefix = "";
+                if (File.Exists(tomlPath))
+                {
+                    var lines = await File.ReadAllLinesAsync(tomlPath);
+                    string? current = null;
+                    foreach (var raw in lines)
+                    {
+                        var line = raw.Trim();
+                        if (string.IsNullOrEmpty(line) || line.StartsWith("#")) continue;
+                        if (line.StartsWith("[") && line.EndsWith("]"))
+                        {
+                            current = line.Substring(1, line.Length - 2).Trim();
+                            continue;
+                        }
+                        if (line.StartsWith("retry_prefix"))
+                        {
+                            var idx = line.IndexOf('=');
+                            if (idx >= 0) _npcRetryPrefix = line.Substring(idx + 1).Trim().Trim('"');
+                            continue;
+                        }
+                        if (current != null && line.Contains("= "))
+                        {
+                            var idx = line.IndexOf('=');
+                            var key = line.Substring(0, idx).Trim();
+                            var val = line.Substring(idx + 1).Trim().Trim('"');
+                            if (key == "question")
+                            {
+                                if (!_npcPrompts.ContainsKey(current)) _npcPrompts[current] = (val, string.Empty);
+                                else _npcPrompts[current] = (val, _npcPrompts[current].constraints);
+                            }
+                            else if (key == "constraints")
+                            {
+                                if (!_npcPrompts.ContainsKey(current)) _npcPrompts[current] = (string.Empty, val);
+                                else _npcPrompts[current] = (_npcPrompts[current].question, val);
+                            }
+                        }
+                    }
+                }
+
+                Progress = 0.05;
+
+                // Ask LLM for tiers per-stat
+                var statKeys = new[] { "ability_score_modifier", "perception_modifier", "skill_modifier", "ac", "saving_throw", "hp", "resistance_or_weakness", "strike_attack_bonus", "strike_damage_roll" };
+                var responses = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                int total = statKeys.Length;
+                int done = 0;
+
+                foreach (var key in statKeys)
+                {
+                    string questionTemplate = _npcPrompts.ContainsKey(key) ? _npcPrompts[key].question : null;
+                    string constraints = _npcPrompts.ContainsKey(key) ? _npcPrompts[key].constraints : string.Empty;
+                    if (string.IsNullOrWhiteSpace(questionTemplate))
+                    {
+                        // Fallback question
+                        questionTemplate = key switch
+                        {
+                            "ability_score_modifier" => "Based on the description, how would you rate ability scores for this character?",
+                            "perception_modifier" => "Based on the description, how would you rate perception for this character?",
+                            "skill_modifier" => "Based on the description, how would you rate skills for this character?",
+                            "ac" => "Based on the description, how would you rate the armor class (AC) for this character?",
+                            "saving_throw" => "Based on the description, how would you rate saving throws for this character?",
+                            "hp" => "Based on the description, how would you rate hit points for this character?",
+                            "resistance_or_weakness" => "Based on the description, does this character have notable resistances or weaknesses?",
+                            "strike_attack_bonus" => "Based on the description, how would you rate the strike attack bonus for this character?",
+                            "strike_damage_roll" => "Based on the description, what is the strike damage dice roll for this character?",
+                            _ => $"Based on the description, provide a value for {key}."
+                        };
+                    }
+
+                    // Replace placeholders
+                    var prompt = questionTemplate.Replace("{level}", SelectedLevel.ToString()).Replace("{system}", SelectedSystem).Replace("{description}", Description ?? string.Empty).Replace("{name}", Name ?? string.Empty).Replace("{modifierTier}", "");
+                    string lastResponse = string.Empty;
+                    bool ok = false;
+                    string finalResp = string.Empty;
+                    for (int attempt = 1; attempt <= 3; attempt++)
+                    {
+                        StatusMessage = $"Asking LLM for {key} (attempt {attempt})...";
+                        var resp = await CurrentService.AskAsync(CurrentAddress, SelectedModel!, prompt, ImageItems.Select(i => i.Path).ToList());
+                        var trimmed = resp?.Trim() ?? string.Empty;
+
+                        // If LLM returned an explicit Error: prefix, consider that a failure
+                        if (trimmed.StartsWith("Error:", StringComparison.OrdinalIgnoreCase))
+                        {
+                            // feed back to next attempt
+                            prompt = _npcRetryPrefix + "\nPrevious error: " + trimmed + "\n" + prompt;
+                            lastResponse = trimmed;
+                            continue;
+                        }
+
+                        // Validate against constraints if available (simple check for listed words)
+                        if (!string.IsNullOrWhiteSpace(constraints))
+                        {
+                            var allowed = constraints.Trim();
+                            // extract words inside the constraint description (e.g., Respond with only a single word: Extreme, High, Moderate, or Low.)
+                            var optionsStart = allowed.IndexOf(":");
+                            List<string> options = new();
+                            if (optionsStart >= 0)
+                            {
+                                var after = allowed.Substring(optionsStart + 1);
+                                // split by commas and 'or'
+                                var parts = after.Split(new[] { ',', '\n' }, StringSplitOptions.RemoveEmptyEntries);
+                                foreach (var p in parts)
+                                {
+                                    var t = p.Replace("or", "", StringComparison.OrdinalIgnoreCase).Trim();
+                                    if (!string.IsNullOrEmpty(t)) options.Add(t.Trim().Trim('.'));
+                                }
+                            }
+
+                            if (options.Count > 0)
+                            {
+                                // check if trimmed matches one of options
+                                if (options.Any(o => string.Equals(o, trimmed, StringComparison.OrdinalIgnoreCase)))
+                                {
+                                    ok = true;
+                                    finalResp = trimmed;
+                                    break;
+                                }
+                                else
+                                {
+                                    // try extracting first word
+                                    var firstWord = trimmed.Split(new[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault() ?? string.Empty;
+                                    if (options.Any(o => string.Equals(o, firstWord, StringComparison.OrdinalIgnoreCase)))
+                                    {
+                                        ok = true;
+                                        finalResp = firstWord;
+                                        break;
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                // no options parsed, accept any non-empty response
+                                if (!string.IsNullOrWhiteSpace(trimmed)) { ok = true; finalResp = trimmed; break; }
+                            }
+
+                            // not valid: prepare retry prompt
+                            prompt = _npcRetryPrefix + "\nPrevious response: " + trimmed + "\nPlease respond with the format required: " + constraints + "\n" + questionTemplate.Replace("{level}", SelectedLevel.ToString()).Replace("{system}", SelectedSystem);
+                            lastResponse = trimmed;
+                            continue;
+                        }
+                        else
+                        {
+                            if (!string.IsNullOrWhiteSpace(trimmed)) { ok = true; finalResp = trimmed; break; }
+                            prompt = _npcRetryPrefix + "\nPrevious response: " + trimmed + "\n" + prompt;
+                            lastResponse = trimmed;
+                        }
+                    }
+
+                    if (!ok)
+                    {
+                        StatusMessage = $"LLM failed to provide valid response for {key} after 3 attempts. Last response: {lastResponse}";
+                        IsGenerating = false;
+                        return;
+                    }
+
+                    responses[key] = finalResp;
+                    done++;
+                    Progress = 0.05 + 0.85 * ((double)done / total);
+                }
+
+                // Finished LLM prompts
+                Progress = 0.95;
+
+                // Load template JSON
                 var templatePath = Path.Combine(cwd, "foundry_templates", "npc_template.json");
                 if (!File.Exists(templatePath))
                 {
                     StatusMessage = $"Template not found at {templatePath}";
+                    IsGenerating = false;
                     return;
                 }
 
@@ -189,15 +383,29 @@ namespace finder2e_foundry_converter.ViewModels
                 }
                 details["level"].AsObject()["value"] = SelectedLevel;
 
-                // Default to pf2e for now
+                string gameSystem = SelectedSystem ?? "pf2e";
-                string gameSystem = "pf2e";
 
-                // Compute numeric stats using NpcConverter helper functions with conservative tiers
+                // Map tiers (normalize)
-                var abilityTier = "moderate";
+                string GetTier(string key)
-                var perceptionTier = "moderate";
+                {
-                var acTier = "moderate";
+                    if (!responses.TryGetValue(key, out var r)) return "moderate";
-                var savingTier = "moderate";
+                    var t = r.Trim().ToLowerInvariant();
-                var hpTier = "moderate";
+                    if (t.StartsWith("extreme")) return "extreme";
+                    if (t.StartsWith("high")) return "high";
+                    if (t.StartsWith("moderate")) return "moderate";
+                    if (t.StartsWith("low")) return "low";
+                    if (t.StartsWith("terrible")) return "terrible";
+                    if (t.StartsWith("yes")) return "yes";
+                    if (t.StartsWith("no")) return "no";
+                    return t;
+                }
+
+                var abilityTier = GetTier("ability_score_modifier");
+                var perceptionTier = GetTier("perception_modifier");
+                var skillTier = GetTier("skill_modifier");
+                var acTier = GetTier("ac");
+                var savingTier = GetTier("saving_throw");
+                var hpTier = GetTier("hp");
 
                 var abilities = new JsonObject();
                 string[] abilityNames = new[] { "str", "dex", "con", "int", "wis", "cha" };
@@ -237,8 +445,39 @@ namespace finder2e_foundry_converter.ViewModels
                 var hpRes = NpcConverter.Hp(SelectedLevel, hpTier, gameSystem);
                 attributes["hp"] = new JsonObject { ["value"] = hpRes.IsSuccess ? hpRes.Value : 10, ["temp"] = 0, ["max"] = hpRes.IsSuccess ? hpRes.Value : 10, ["details"] = string.Empty };
 
-                // Skills (leave empty for now)
+                // Skills: populate common PF2e skills using skillTier
-                systemNode["skills"] = new JsonObject();
+                var skillsNode = new JsonObject();
+                var skillList = new[] { "acrobatics", "arcana", "athletics", "crafting", "deception", "diplomacy", "intimidation", "lore", "medicine", "nature", "occultism", "performance", "religion", "society", "stealth", "survival", "thievery" };
+                foreach (var sk in skillList)
+                {
+                    var skRes = NpcConverter.SkillModifier(SelectedLevel, skillTier, gameSystem);
+                    skillsNode[sk] = new JsonObject { ["value"] = skRes.IsSuccess ? skRes.Value : 0 };
+                }
+                systemNode["skills"] = skillsNode;
+
+                // Items: create a basic Strike item using strike attack bonus and damage from LLM response tiers
+                var items = new JsonArray();
+                var strikeTier = GetTier("strike_attack_bonus");
+                var strikeAttack = NpcConverter.StrikeAttackBonus(SelectedLevel, strikeTier, gameSystem);
+                var strikeDamage = NpcConverter.StrikeDamageRoll(SelectedLevel, strikeTier, gameSystem);
+                var strikeAvgRes = NpcConverter.StrikeDamageAverage(SelectedLevel, strikeTier, gameSystem);
+
+                if (strikeAttack.IsSuccess || strikeDamage.IsSuccess)
+                {
+                    var itemObj = new JsonObject
+                    {
+                        ["name"] = "Strike",
+                        ["type"] = "weapon",
+                        ["system"] = new JsonObject
+                        {
+                            ["attack"] = new JsonObject { ["value"] = strikeAttack.IsSuccess ? strikeAttack.Value : 0 },
+                            ["damage"] = new JsonObject { ["dice"] = strikeDamage.IsSuccess ? strikeDamage.Value : string.Empty, ["average"] = strikeAvgRes.IsSuccess ? strikeAvgRes.Value : 0 }
+                        }
+                    };
+                    items.Add(itemObj);
+                }
+
+                node["items"] = items;
 
                 // Finalize JSON text
                 GeneratedNpcJson = node.ToJsonString(new JsonSerializerOptions { WriteIndented = true });
@@ -252,11 +491,16 @@ namespace finder2e_foundry_converter.ViewModels
                 TemporaryNpcPath = tempPath;
 
                 StatusMessage = $"NPC generated and saved to temporary path: {tempPath}";
+                Progress = 1.0;
             }
             catch (Exception ex)
             {
                 StatusMessage = $"Error generating NPC: {ex.Message}";
             }
+            finally
+            {
+                IsGenerating = false;
+            }
         }
 
         [RelayCommand]

views/mainwindow.axaml

@@ -57,13 +57,19 @@
                           ItemsSource="{Binding Levels}"
                           SelectedItem="{Binding SelectedLevel}"/>
 
+                <Label Content="System:"/>
+                <ComboBox HorizontalAlignment="Stretch"
+                          ItemsSource="{Binding Systems}"
+                          SelectedItem="{Binding SelectedSystem}"/>
+
                 <Label Content="Description:"/>
                 <TextBox Text="{Binding Description}" AcceptsReturn="True" Height="100" PlaceholderText="Enter description here..."/>
             </StackPanel>
 
             <Button Content="Generate" HorizontalAlignment="Stretch" HorizontalContentAlignment="Center"
-                    Command="{Binding GenerateCommand}" FontWeight="Bold"/>
+                    Command="{Binding GenerateCommand}" FontWeight="Bold" IsEnabled="{Binding CanGenerate}"/>
 
+            <ProgressBar Minimum="0" Maximum="1" Value="{Binding Progress}" IsVisible="{Binding IsGenerating}" Height="10"/> 
             <TextBlock Text="{Binding StatusMessage}" TextWrapping="Wrap" Margin="0,10,0,0"/>
 
             <StackPanel Spacing="5" Margin="0,10,0,0" IsVisible="{Binding IsNpcSelected}">