BattleTool and full message collection instead of summary

ChatRPG/API/ReActAgentChain.cs

@@ -79,7 +79,7 @@ public ReActAgentChain(
         string? gameSummary = null,
         string inputKey = "input",
         string outputKey = "text",
-        int maxActions = 10)
+        int maxActions = 20)
     {
         _model = model;
         _model.Settings!.StopSequences = ["Observation", "[END]"];
@@ -116,7 +116,7 @@ public ReActAgentChain(
         string? gameSummary = null,
         string inputKey = "input",
         string outputKey = "text",
-        int maxActions = 10) : this(model, reActPrompt, gameSummary, inputKey, outputKey, maxActions)
+        int maxActions = 20) : this(model, reActPrompt, gameSummary, inputKey, outputKey, maxActions)
     {
         _actionPrompt = actionPrompt ?? string.Empty;
     }
@@ -130,7 +130,7 @@ public ReActAgentChain(
         string? gameSummary = null,
         string inputKey = "input",
         string outputKey = "text",
-        int maxActions = 10) : this(model, reActPrompt, gameSummary, inputKey, outputKey, maxActions)
+        int maxActions = 20) : this(model, reActPrompt, gameSummary, inputKey, outputKey, maxActions)
     {
         _characters = characters;
         _playerCharacter = playerCharacter;
@@ -215,6 +215,7 @@ await _conversationBufferMemory.ChatHistory.AddMessage(new Message("Thought:", M
             }
         }
 
-        throw new ReActChainNoFinalAnswerReachedException("The ReAct Chain could not reach a final answer", values);
+        throw new ReActChainNoFinalAnswerReachedException($"The ReAct Chain could not reach a final answer. " +
+                                                          $"Values: {values}", values);
     }
 }

ChatRPG/API/ReActLlmClient.cs

@@ -1,6 +1,7 @@
 using ChatRPG.API.Tools;
 using ChatRPG.Data.Models;
 using LangChain.Chains.StackableChains.Agents.Tools;
+using LangChain.Providers;
 using LangChain.Providers.OpenAI;
 using LangChain.Providers.OpenAI.Predefined;
 using static LangChain.Chains.Chain;
@@ -12,6 +13,7 @@ public class ReActLlmClient : IReActLlmClient
     private readonly IConfiguration _configuration;
     private readonly OpenAiProvider _provider;
     private readonly string _reActPrompt;
+    private readonly bool _narratorDebugMode;
 
     public ReActLlmClient(IConfiguration configuration)
     {
@@ -20,15 +22,18 @@ public ReActLlmClient(IConfiguration configuration)
         _configuration = configuration;
         _reActPrompt = _configuration.GetSection("SystemPrompts").GetValue<string>("ReAct")!;
         _provider = new OpenAiProvider(_configuration.GetSection("ApiKeys").GetValue<string>("OpenAI")!);
+        _narratorDebugMode = _configuration.GetValue<bool>("NarrativeChainDebug")!;
     }
 
     public async Task<string> GetChatCompletionAsync(Campaign campaign, string actionPrompt, string input)
     {
-        var llm = new Gpt4Model(_provider)
+        var llm = new Gpt4OmniModel(_provider)
         {
             Settings = new OpenAiChatSettings() { UseStreaming = false, Temperature = 0.7 }
         };
-        var agent = new ReActAgentChain(llm, _reActPrompt, actionPrompt: actionPrompt, campaign.GameSummary);
+
+        var agent = new ReActAgentChain(_narratorDebugMode ? llm.UseConsoleForDebug() : llm, _reActPrompt,
+            actionPrompt: actionPrompt, campaign.GameSummary);
         var tools = CreateTools(campaign);
         foreach (var tool in tools)
         {
@@ -42,13 +47,14 @@ public async Task<string> GetChatCompletionAsync(Campaign campaign, string actio
     public async IAsyncEnumerable<string> GetStreamedChatCompletionAsync(Campaign campaign, string actionPrompt,
         string input)
     {
-        var agentLlm = new Gpt4Model(_provider)
+        var llm = new Gpt4OmniModel(_provider)
         {
             Settings = new OpenAiChatSettings() { UseStreaming = true, Temperature = 0.7 }
         };
 
-        var eventProcessor = new LlmEventProcessor(agentLlm);
-        var agent = new ReActAgentChain(agentLlm, _reActPrompt, actionPrompt: actionPrompt, campaign.GameSummary);
+        var eventProcessor = new LlmEventProcessor(llm);
+        var agent = new ReActAgentChain(_narratorDebugMode ? llm.UseConsoleForDebug() : llm, _reActPrompt,
+            actionPrompt: actionPrompt, campaign.GameSummary);
         var tools = CreateTools(campaign);
         foreach (var tool in tools)
         {
@@ -81,7 +87,8 @@ private List<AgentTool> CreateTools(Campaign campaign)
             "Input to this tool must be in the following RAW JSON format: {\"input\": \"The player's input\", " +
             "\"severity\": \"Describes how devastating the injury to the character will be based on the action. " +
             "Can be one of the following values: {low, medium, high, extraordinary}}\". Do not use markdown, " +
-            "only raw JSON as input. Use this tool only once per character at most.");
+            "only raw JSON as input. Use this tool only once per character at most and only if they are not engaged " +
+            "in battle.");
         tools.Add(woundCharacterTool);
 
         var healCharacterTool = new HealCharacterTool(_configuration, campaign, utils, "healcharactertool",
@@ -97,9 +104,39 @@ private List<AgentTool> CreateTools(Campaign campaign)
             "Do not use markdown, only raw JSON as input. Use this tool only once per character at most.");
         tools.Add(healCharacterTool);
 
-        // Use battle when an attack can be mitigated or dodged by the involved participants.
-        // This tool is appropriate for combat, battle between multiple participants,
-        // or attacks that can be avoided and a to-hit roll would be needed in order to determine a hit.
+        var battleTool = new BattleTool(_configuration, campaign, utils, "battletool",
+            "Use the battle tool to resolve battle or combat between two participants. A participant is " +
+            "a single character and cannot be a combination of characters. If there are more " +
+            "than two participants, the tool must be used once per attacker to give everyone a chance at fighting. " +
+            "The battle tool will give each participant a chance to fight the other participant. The tool should " +
+            "also be used when an attack can be mitigated or dodged by the involved participants. It is also " +
+            "possible for either or both participants to miss. A hit chance specifier will help adjust the chance " +
+            "that a participant gets to retaliate. Example: There are only two combatants. Call the tool only ONCE " +
+            "since both characters get an attack. Another example: There are three combatants, the Player's character " +
+            "and two assassins. The battle tool is called first with the Player's character as participant one and " +
+            "one of the assassins as participant two. Chances are high that the player will hit the assassin but " +
+            "assassins must be precise, making it harder to hit, however, they deal high damage if they hit. We " +
+            "observe that the participant one hits participant two and participant two misses participant one. " +
+            "After this round of battle has been resolved, call the tool again with the Player's character as " +
+            "participant one and the other assassin as participant two. Since participant one in this case has " +
+            "already hit once during this narrative, we impose a penalty to their hit chance, which is " +
+            "accumulative for each time they hit an enemy during battle. The damage severity describes how " +
+            "powerful the attack is which is derived from the narrative description of the attacks. " +
+            "If the participants engage in a friendly sparring fight, does not intend to hurt, or does mock battle, " +
+            "the damage severity is <harmless>. " +
+            "If there are no direct description, estimate the impact of an attack based on the character type and " +
+            "their description. Input to this tool must be in the following RAW JSON format: {\"participant1\": " +
+            "{\"name\": \"<name of participant one>\", \"description\": \"<description of participant one>\"}, " +
+            "\"participant2\": {\"name\": \"<name of participant two>\", \"description\": " +
+            "\"<description of participant two>\"}, \"participant1HitChance\": \"<hit chance specifier for " +
+            "participant one>\", \"participant2HitChance\": \"<hit chance specifier for participant two>\", " +
+            "\"participant1DamageSeverity\": \"<damage severity for participant one>\", " +
+            "\"participant2DamageSeverity\": \"<damage severity for participant two>\"} where participant#HitChance " +
+            "specifiers are one of the following {high, medium, low, impossible} and participant#DamageSeverity is " +
+            "one of the following {harmless, low, medium, high, extraordinary}. Do not use markdown, only raw JSON as " +
+            "input. The narrative battle is over when each character has had the chance to attack another character at " +
+            "most once.");
+        tools.Add(battleTool);
 
         return tools;
     }

ChatRPG/API/Tools/BattleInput.cs

@@ -0,0 +1,58 @@
+namespace ChatRPG.API.Tools;
+
+public class BattleInput
+{
+    private static readonly HashSet<string> ValidChancesToHit =
+        ["high", "medium", "low", "impossible"];
+
+    private static readonly HashSet<string> ValidDamageSeverities =
+        ["harmless", "low", "medium", "high", "extraordinary"];
+
+    public CharacterInput? Participant1 { get; set; }
+    public CharacterInput? Participant2 { get; set; }
+    public string? Participant1HitChance { get; set; }
+    public string? Participant2HitChance { get; set; }
+    public string? Participant1DamageSeverity { get; set; }
+    public string? Participant2DamageSeverity { get; set; }
+
+    public bool IsValid(out List<string> validationErrors)
+    {
+        validationErrors = [];
+
+        if (Participant1 == null)
+        {
+            validationErrors.Add("Participant1 is required.");
+        }
+        else if (!Participant1.IsValidForBattle(out var participant1Errors))
+        {
+            validationErrors.AddRange(participant1Errors.Select(e => $"Participant1: {e}"));
+        }
+
+        if (Participant2 == null)
+        {
+            validationErrors.Add("Participant2 is required.");
+        }
+        else if (!Participant2.IsValidForBattle(out var participant2Errors))
+        {
+            validationErrors.AddRange(participant2Errors.Select(e => $"Participant2: {e}"));
+        }
+
+        if (Participant1HitChance != null && !ValidChancesToHit.Contains(Participant1HitChance))
+            validationErrors.Add(
+                "Participant1ChanceToHit must be one of the following: high, medium, low, impossible.");
+
+        if (Participant2HitChance != null && !ValidChancesToHit.Contains(Participant2HitChance))
+            validationErrors.Add(
+                "Participant2ChanceToHit must be one of the following: high, medium, low, impossible.");
+
+        if (Participant1DamageSeverity != null && !ValidDamageSeverities.Contains(Participant1DamageSeverity))
+            validationErrors.Add(
+                "Participant1DamageSeverity must be one of the following: harmless, low, medium, high, extraordinary.");
+
+        if (Participant2DamageSeverity != null && !ValidDamageSeverities.Contains(Participant2DamageSeverity))
+            validationErrors.Add(
+                "Participant2DamageSeverity must be one of the following: harmless, low, medium, high, extraordinary.");
+
+        return validationErrors.Count == 0;
+    }
+}

ChatRPG/API/Tools/BattleTool.cs

@@ -0,0 +1,174 @@
+using System.Text;
+using System.Text.Json;
+using ChatRPG.Data.Models;
+using LangChain.Chains.StackableChains.Agents.Tools;
+
+namespace ChatRPG.API.Tools;
+
+public class BattleTool(
+    IConfiguration configuration,
+    Campaign campaign,
+    ToolUtilities utilities,
+    string name,
+    string? description = null) : AgentTool(name, description)
+{
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        PropertyNameCaseInsensitive = true
+    };
+
+    private static readonly Dictionary<string, double> HitChance = new()
+    {
+        { "high", 0.9 },
+        { "medium", 0.5 },
+        { "low", 0.3 },
+        { "impossible", 0.01 }
+    };
+
+    private static readonly Dictionary<string, (int, int)> DamageRanges = new()
+    {
+        { "harmless", (0, 1) },
+        { "low", (5, 10) },
+        { "medium", (10, 20) },
+        { "high", (15, 25) },
+        { "extraordinary", (25, 80) }
+    };
+
+    public override async Task<string> ToolTask(string input, CancellationToken token = new CancellationToken())
+    {
+        try
+        {
+            var battleInput = JsonSerializer.Deserialize<BattleInput>(ToolUtilities.RemoveMarkdown(input), JsonOptions) ??
+                              throw new JsonException("Failed to deserialize");
+            var instruction = configuration.GetSection("SystemPrompts").GetValue<string>("BattleInstruction")!;
+
+            if (!battleInput.IsValid(out var errors))
+            {
+                var errorMessage = new StringBuilder();
+                errorMessage.Append(
+                    "Invalid input provided for the battle. Please provide valid input and correct the following errors:\n");
+                foreach (var validationError in errors)
+                {
+                    errorMessage.Append(validationError + "\n");
+                }
+
+                return errorMessage.ToString();
+            }
+
+            var participant1 = await utilities.FindCharacter(campaign,
+                $"{{\"name\": \"{battleInput.Participant1!.Name}\", " +
+                $"\"description\": \"{battleInput.Participant1.Description}\"}}", instruction);
+            var participant2 = await utilities.FindCharacter(campaign,
+                $"{{\"name\": \"{battleInput.Participant2!.Name}\", " +
+                $"\"description\": \"{battleInput.Participant2.Description}\"}}", instruction);
+
+            // Create dummy characters if they do not exist and pray that the archive chain will update them
+            participant1 ??= new Character(campaign, campaign.Player.Environment, CharacterType.Humanoid,
+                battleInput.Participant1.Name!, battleInput.Participant1.Description!, false);
+            participant2 ??= new Character(campaign, campaign.Player.Environment, CharacterType.Humanoid,
+                battleInput.Participant2.Name!, battleInput.Participant2.Description!, false);
+
+            var firstHitter = DetermineFirstHitter(participant1, participant2);
+
+            Character secondHitter;
+            string firstHitChance;
+            string secondHitChance;
+            string firstHitSeverity;
+            string secondHitSeverity;
+
+            if (firstHitter == participant1)
+            {
+                secondHitter = participant2;
+                firstHitChance = battleInput.Participant1HitChance!;
+                secondHitChance = battleInput.Participant2HitChance!;
+                firstHitSeverity = battleInput.Participant1DamageSeverity!;
+                secondHitSeverity = battleInput.Participant2DamageSeverity!;
+            }
+            else
+            {
+                secondHitter = participant1;
+                firstHitChance = battleInput.Participant2HitChance!;
+                secondHitChance = battleInput.Participant1HitChance!;
+                firstHitSeverity = battleInput.Participant2DamageSeverity!;
+                secondHitSeverity = battleInput.Participant1DamageSeverity!;
+            }
+
+            return ResolveCombat(firstHitter, secondHitter, firstHitChance, secondHitChance, firstHitSeverity,
+                       secondHitSeverity) + $" {firstHitter.Name} and {secondHitter.Name}'s battle has " +
+                   "been resolved and this pair can not be used for the battle tool again.";
+        }
+        catch (Exception)
+        {
+            return
+                "Could not execute the battle. Tool input format was invalid. " +
+                "Please provide the input in valid JSON.";
+        }
+    }
+
+    private static string ResolveCombat(Character firstHitter, Character secondHitter, string firstHitChance,
+        string secondHitChance, string firstHitSeverity, string secondHitSeverity)
+    {
+        var resultString = $"{firstHitter.Name} described as \"{firstHitter.Description}\" fights " +
+                           $"{secondHitter.Name} described as \"{secondHitter.Description}\"\n";
+
+
+        resultString += ResolveAttack(firstHitter, secondHitter, firstHitChance, firstHitSeverity);
+        if (secondHitter.CurrentHealth <= 0)
+        {
+            return resultString;
+        }
+
+        resultString += " " + ResolveAttack(secondHitter, firstHitter, secondHitChance, secondHitSeverity);
+
+        return resultString;
+    }
+
+    private static string ResolveAttack(Character damageDealer, Character damageTaker, string hitChance,
+        string hitSeverity)
+    {
+        var resultString = string.Empty;
+        Random rand = new Random();
+        var doesAttackHit = rand.NextDouble() <= HitChance[hitChance];
+
+        if (doesAttackHit)
+        {
+            var (minDamage, maxDamage) = DamageRanges[hitSeverity];
+            var damage = rand.Next(minDamage, maxDamage);
+            resultString += $"{damageDealer.Name} deals {damage} damage to {damageTaker.Name}. ";
+            if (damageTaker.AdjustHealth(-damage))
+            {
+                if (damageTaker.IsPlayer)
+                {
+                    return resultString + $"The player {damageTaker.Name} has no remaining health points. " +
+                           "Their adventure is over. No more actions can be taken.";
+                }
+
+                return resultString +
+                       $"With no health points remaining, {damageTaker.Name} dies and can no longer " +
+                       "perform actions in the narrative.";
+            }
+
+            return resultString +
+                   $"They have {damageTaker.CurrentHealth} health points out of {damageTaker.MaxHealth} remaining.";
+        }
+
+        return $"{damageDealer.Name} misses their attack on {damageTaker.Name}.";
+    }
+
+    private static Character DetermineFirstHitter(Character participant1, Character participant2)
+    {
+        var rand = new Random();
+        var firstHitRoll = rand.NextDouble();
+
+        return (participant1.Type - participant2.Type) switch
+        {
+            0 => firstHitRoll <= 0.5 ? participant1 : participant2,
+            1 => firstHitRoll <= 0.4 ? participant1 : participant2,
+            2 => firstHitRoll <= 0.3 ? participant1 : participant2,
+            >= 3 => firstHitRoll <= 0.2 ? participant1 : participant2,
+            -1 => firstHitRoll <= 0.6 ? participant1 : participant2,
+            -2 => firstHitRoll <= 0.7 ? participant1 : participant2,
+            <= -3 => firstHitRoll <= 0.8 ? participant1 : participant2
+        };
+    }
+}