Share one message instance through the conversation.

Author: Oceania2018

src/Infrastructure/BotSharp.Abstraction/Conversations/Models/RoleDialogModel.cs

@@ -1,3 +1,4 @@
+using BotSharp.Abstraction.Functions.Models;
 using BotSharp.Abstraction.Models;
 
 namespace BotSharp.Abstraction.Conversations.Models;
@@ -38,6 +39,8 @@ public class RoleDialogModel : ITrackableMessage
     [JsonIgnore(Condition = JsonIgnoreCondition.Always)]
     public bool StopCompletion { get; set; }
 
+    public FunctionCallFromLlm Instruction { get; set; }
+
     private RoleDialogModel()
     {
     }

src/Infrastructure/BotSharp.Abstraction/Routing/IRoutingHandler.cs

@@ -1,5 +1,4 @@
 using BotSharp.Abstraction.Functions.Models;
-using BotSharp.Abstraction.Models;
 
 namespace BotSharp.Abstraction.Routing;
 
@@ -19,5 +18,5 @@ void SetRouter(Agent router) { }
 
     void SetDialogs(List<RoleDialogModel> dialogs) { }
 
-    Task<RoleDialogModel> Handle(IRoutingService routing, FunctionCallFromLlm inst);
+    Task<bool> Handle(IRoutingService routing, FunctionCallFromLlm inst, RoleDialogModel message);
 }

src/Infrastructure/BotSharp.Abstraction/Routing/IRoutingService.cs

@@ -8,7 +8,7 @@ public interface IRoutingService
     void ResetRecursiveCounter();
     void RefreshDialogs();
     Task<FunctionCallFromLlm> GetNextInstruction();
-    Task<RoleDialogModel> InvokeAgent(string agentId);
-    Task<RoleDialogModel> InstructLoop();
-    Task<RoleDialogModel> ExecuteOnce(Agent agent);
+    Task<bool> InvokeAgent(string agentId, RoleDialogModel message);
+    Task<bool> InstructLoop(RoleDialogModel message);
+    Task<bool> ExecuteOnce(Agent agent, RoleDialogModel message);
 }

src/Infrastructure/BotSharp.Abstraction/Routing/Models/RoutingArgs.cs

@@ -1,10 +1,7 @@
 namespace BotSharp.Abstraction.Routing.Models;
 
-public class RoutingArgs : ITrackableMessage
+public class RoutingArgs
 {
-    [JsonPropertyName("message_id")]
-    public string MessageId { get; set; }
-
     [JsonPropertyName("function")]
     public string Function { get; set; }
 

src/Infrastructure/BotSharp.Core/Conversations/Services/ConversationService.SendMessage.cs

@@ -8,7 +8,7 @@ namespace BotSharp.Core.Conversations.Services;
 public partial class ConversationService
 {
     public async Task<bool> SendMessage(string agentId, 
-        RoleDialogModel incoming,
+        RoleDialogModel message,
         Func<RoleDialogModel, Task> onMessageReceived,
         Func<RoleDialogModel, Task> onFunctionExecuting,
         Func<RoleDialogModel, Task> onFunctionExecuted)
@@ -18,16 +18,16 @@ public async Task<bool> SendMessage(string agentId,
         var agentService = _services.GetRequiredService<IAgentService>();
         Agent agent = await agentService.LoadAgent(agentId);
 
-        var message = $"Received [{agent.Name}] {incoming.Role}: {incoming.Content}";
+        var content = $"Received [{agent.Name}] {message.Role}: {message.Content}";
 #if DEBUG
-        Console.WriteLine(message, Color.OrangeRed);
+        Console.WriteLine(content, Color.OrangeRed);
 #else
-        _logger.LogInformation(message);
+        _logger.LogInformation(content);
 #endif
 
-        incoming.CurrentAgentId = agent.Id;
+        message.CurrentAgentId = agent.Id;
 
-        _storage.Append(_conversationId, incoming);
+        _storage.Append(_conversationId, message);
 
         var hooks = _services.GetServices<IConversationHook>().ToList();
 
@@ -37,13 +37,13 @@ public async Task<bool> SendMessage(string agentId,
             hook.SetAgent(agent)
                 .SetConversation(conversation);
 
-            await hook.OnMessageReceived(incoming);
+            await hook.OnMessageReceived(message);
 
             // Interrupted by hook
-            if (incoming.StopCompletion)
+            if (message.StopCompletion)
             {
-                await onMessageReceived(incoming);
-                _storage.Append(_conversationId, incoming);
+                await onMessageReceived(message);
+                _storage.Append(_conversationId, message);
                 return true;
             }
         }
@@ -52,19 +52,19 @@ public async Task<bool> SendMessage(string agentId,
         var routing = _services.GetRequiredService<IRoutingService>();
         var settings = _services.GetRequiredService<RoutingSettings>();
 
-        var response = agentId == settings.RouterId ?
-            await routing.InstructLoop() :
-            await routing.ExecuteOnce(agent);
+        var ret = agentId == settings.RouterId ?
+            await routing.InstructLoop(message) :
+            await routing.ExecuteOnce(agent, message);
 
-        await HandleAssistantMessage(response, onMessageReceived);
+        await HandleAssistantMessage(message, onMessageReceived);
 
         var statistics = _services.GetRequiredService<ITokenStatistics>();
         statistics.PrintStatistics();
 
         routing.ResetRecursiveCounter();
         routing.RefreshDialogs();
 
-        return true;
+        return ret;
     }
 
     private async Task<Conversation> GetConversationRecord(string agentId)

src/Infrastructure/BotSharp.Core/Routing/Functions/RouteToAgentFn.cs

@@ -66,14 +66,11 @@ public async Task<bool> Execute(RoleDialogModel message)
             else
             {
                 message.CurrentAgentId = targetAgent.Id;
-                message.Content = $"Routing to {args.AgentName}";
             }
         }
 
         _context.Push(message.CurrentAgentId);
 
-        // Set default execution data
-        message.Data = JsonSerializer.Deserialize<JsonElement>(message.FunctionArgs);
         return true;
     }
 

src/Infrastructure/BotSharp.Core/Routing/Handlers/ContinueExecuteTaskRoutingHandler.cs

@@ -26,19 +26,15 @@ public ContinueExecuteTaskRoutingHandler(IServiceProvider services, ILogger<Cont
     {
     }
 
-    public async Task<RoleDialogModel> Handle(IRoutingService routing, FunctionCallFromLlm inst)
+    public async Task<bool> Handle(IRoutingService routing, FunctionCallFromLlm inst, RoleDialogModel message)
     {
         var db = _services.GetRequiredService<IBotSharpRepository>();
         var record = db.GetAgents(inst.AgentName).FirstOrDefault();
 
-        var result = new RoleDialogModel(AgentRole.Function, inst.Question)
-        {
-            MessageId = inst.MessageId,
-            FunctionName = inst.Function,
-            FunctionArgs = JsonSerializer.Serialize(inst.Arguments),
-            CurrentAgentId = record.Id
-        };
+        message.FunctionName = inst.Function;
+        message.CurrentAgentId = record.Id;
+        message.FunctionArgs = JsonSerializer.Serialize(inst.Arguments);
 
-        return result;
+        return true;
     }
 }

src/Infrastructure/BotSharp.Core/Routing/Handlers/ConversationEndRoutingHandler.cs

@@ -24,25 +24,21 @@ public ConversationEndRoutingHandler(IServiceProvider services, ILogger<Conversa
     {
     }
 
-    public async Task<RoleDialogModel> Handle(IRoutingService routing, FunctionCallFromLlm inst)
+
+    public async Task<bool> Handle(IRoutingService routing, FunctionCallFromLlm inst, RoleDialogModel message)
     {
-        var result = new RoleDialogModel(AgentRole.Assistant, inst.Response)
-        {
-            MessageId = inst.MessageId,
-            CurrentAgentId = _settings.RouterId,
-            FunctionName = inst.Function,
-            Data = inst
-        };
+        message.Content = inst.Response;
+        message.FunctionName = inst.Function;
 
         var hooks = _services.GetServices<IConversationHook>()
             .OrderBy(x => x.Priority)
             .ToList();
 
         foreach (var hook in hooks)
         {
-            await hook.OnConversationEnding(result);
+            await hook.OnConversationEnding(message);
         }
 
-        return result;
+        return true;
     }
 }

src/Infrastructure/BotSharp.Core/Routing/Handlers/HumanInterventionNeededHandler.cs

@@ -11,8 +11,6 @@ public class HumanInterventionNeededHandler : RoutingHandlerBase, IRoutingHandle
 
     public string Description => "Reach out to human being, customer service or customer representative.";
 
-    private readonly RoutingSettings _settings;
-
     public List<NameDesc> Parameters => new List<NameDesc>
     {
         new NameDesc("reason", "why need customer service"),
@@ -22,28 +20,23 @@ public class HumanInterventionNeededHandler : RoutingHandlerBase, IRoutingHandle
     public HumanInterventionNeededHandler(IServiceProvider services, ILogger<HumanInterventionNeededHandler> logger, RoutingSettings settings)
         : base(services, logger, settings)
     {
-        _settings = settings;
+        
     }
 
-    public async Task<RoleDialogModel> Handle(IRoutingService routing, FunctionCallFromLlm inst)
+    public async Task<bool> Handle(IRoutingService routing, FunctionCallFromLlm inst, RoleDialogModel message)
     {
-        var result = new RoleDialogModel(AgentRole.Assistant, inst.Response)
-        {
-            MessageId = inst.MessageId,
-            CurrentAgentId = _settings.RouterId,
-            FunctionName = inst.Function,
-            Data = inst
-        };
+        message.Role = AgentRole.Assistant;
+        message.Content = inst.Response;
 
         var hooks = _services.GetServices<IConversationHook>()
             .OrderBy(x => x.Priority)
             .ToList();
 
         foreach (var hook in hooks)
         {
-            await hook.OnHumanInterventionNeeded(result);
+            await hook.OnHumanInterventionNeeded(message);
         }
 
-        return result;
+        return true;
     }
 }

src/Infrastructure/BotSharp.Core/Routing/Handlers/InterruptTaskExecutionRoutingHandler.cs

@@ -24,15 +24,11 @@ public InterruptTaskExecutionRoutingHandler(IServiceProvider services, ILogger<I
     {
     }
 
-    public async Task<RoleDialogModel> Handle(IRoutingService routing, FunctionCallFromLlm inst)
+    public async Task<bool> Handle(IRoutingService routing, FunctionCallFromLlm inst, RoleDialogModel message)
     {
-        var result = new RoleDialogModel(AgentRole.User, inst.Reason)
-        {
-            MessageId = inst.MessageId,
-            FunctionName = inst.Function,
-            StopCompletion = true
-        };
-
-        return result;
+        message.FunctionName = inst.Function;
+        message.StopCompletion = true;
+
+        return true;
     }
 }