Features/add graph rule engine

Directory.Packages.props

@@ -10,6 +10,7 @@
     <PackageVersion Include="Google_GenerativeAI.Live" Version="3.6.3" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageVersion Include="Polly" Version="8.4.2" />
+    <PackageVersion Include="RabbitMQ.Client" Version="7.2.0" />
     <PackageVersion Include="SharpFuzz" Version="2.2.0" />
     <PackageVersion Include="SharpHook" Version="5.3.9" />
     <PackageVersion Include="SixLabors.ImageSharp" Version="3.1.12" />

src/Infrastructure/BotSharp.Abstraction/Agents/Models/AgentRule.cs

@@ -8,6 +8,13 @@ public class AgentRule
     [JsonPropertyName("disabled")]
     public bool Disabled { get; set; }
 
-    [JsonPropertyName("criteria")]
-    public string Criteria { get; set; } = string.Empty;
+    [JsonPropertyName("config")]
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public RuleConfig? Config { get; set; }
 }
+
+public class RuleConfig
+{
+    [JsonPropertyName("topology_name")]
+    public string? TopologyName { get; set; }
+}

src/Infrastructure/BotSharp.Abstraction/Coding/Contexts/CodeExecutionContext.cs

@@ -4,4 +4,5 @@ public class CodeExecutionContext
 {
     public AgentCodeScript CodeScript { get; set; }
     public List<KeyValue> Arguments { get; set; } = [];
+    public string? InvokeFrom { get; set; }
 }

src/Infrastructure/BotSharp.Abstraction/Infrastructures/MessageQueues/IMQConsumer.cs

@@ -0,0 +1,21 @@
+namespace BotSharp.Abstraction.Infrastructures.MessageQueues;
+
+/// <summary>
+/// Abstract interface for message queue consumers.
+/// Implement this interface to create consumers that are independent of MQ products (e.g., RabbitMQ, Kafka, Azure Service Bus).
+/// </summary>
+public interface IMQConsumer : IDisposable
+{
+    /// <summary>
+    /// Gets the consumer config
+    /// </summary>
+    object Config { get; }
+
+    /// <summary>
+    /// Handles the received message from the queue.
+    /// </summary>
+    /// <param name="channel">The consumer channel identifier</param>
+    /// <param name="data">The message data as string</param>
+    /// <returns>True if the message was handled successfully, false otherwise</returns>
+    Task<bool> HandleMessageAsync(string channel, string data);
+}

src/Infrastructure/BotSharp.Abstraction/Infrastructures/MessageQueues/IMQService.cs

@@ -0,0 +1,31 @@
+using BotSharp.Abstraction.Infrastructures.MessageQueues.Models;
+
+namespace BotSharp.Abstraction.Infrastructures.MessageQueues;
+
+public interface IMQService : IDisposable
+{
+    /// <summary>
+    /// Subscribe a consumer to the message queue.
+    /// The consumer will be initialized with the appropriate MQ-specific infrastructure.
+    /// </summary>
+    /// <param name="key">Unique identifier for the consumer</param>
+    /// <param name="consumer">The consumer implementing IMQConsumer interface</param>
+    /// <returns>Task<bool> representing the async subscription operation</returns>
+    Task<bool> SubscribeAsync(string key, IMQConsumer consumer);
+
+    /// <summary>
+    /// Unsubscribe a consumer from the message queue.
+    /// </summary>
+    /// <param name="key">Unique identifier for the consumer</param>
+    /// <returns>Task<bool> representing the async unsubscription operation</returns>
+    Task<bool> UnsubscribeAsync(string key);
+
+    /// <summary>
+    /// Publish payload to message queue
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <param name="payload"></param>
+    /// <param name="options"></param>
+    /// <returns></returns>
+    Task<bool> PublishAsync<T>(T payload, MQPublishOptions options);
+}

src/Infrastructure/BotSharp.Abstraction/Infrastructures/MessageQueues/MQConsumerBase.cs

@@ -0,0 +1,51 @@
+using Microsoft.Extensions.Logging;
+
+namespace BotSharp.Abstraction.Infrastructures.MessageQueues;
+
+/// <summary>
+/// Abstract base class for RabbitMQ consumers.
+/// Implements IMQConsumer to allow other projects to define consumers independently of RabbitMQ.
+/// The RabbitMQ-specific infrastructure is handled by RabbitMQService.
+/// </summary>
+public abstract class MQConsumerBase : IMQConsumer
+{
+    protected readonly IServiceProvider _services;
+    protected readonly ILogger _logger;
+    private bool _disposed = false;
+
+    /// <summary>
+    /// Gets the consumer config for this consumer.
+    /// Override this property to customize exchange, queue and routing configuration.
+    /// </summary>
+    public abstract object Config { get; }
+
+    protected MQConsumerBase(
+        IServiceProvider services,
+        ILogger logger)
+    {
+        _services = services;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Handles the received message from the queue.
+    /// </summary>
+    /// <param name="channel">The consumer channel identifier</param>
+    /// <param name="data">The message data as string</param>
+    /// <returns>True if the message was handled successfully, false otherwise</returns>
+    public abstract Task<bool> HandleMessageAsync(string channel, string data);
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        var consumerName = GetType().Name;
+        _logger.LogWarning($"Disposing consumer: {consumerName}");
+        _disposed = true;
+        GC.SuppressFinalize(this);
+    }
+}
+

src/Infrastructure/BotSharp.Abstraction/Infrastructures/MessageQueues/MessageQueueSettings.cs

@@ -0,0 +1,7 @@
+namespace BotSharp.Abstraction.Infrastructures.MessageQueues;
+
+public class MessageQueueSettings
+{
+    public bool Enabled { get; set; }
+    public string Provider { get; set; }
+}

src/Infrastructure/BotSharp.Abstraction/Infrastructures/MessageQueues/Models/MQMessage.cs

@@ -0,0 +1,14 @@
+namespace BotSharp.Abstraction.Infrastructures.MessageQueues.Models;
+
+public class MQMessage<T>
+{
+    public MQMessage(T payload, string messageId)
+    {
+        Payload = payload;
+        MessageId = messageId;
+    }
+
+    public T Payload { get; set; }
+    public string MessageId { get; set; }
+    public DateTime CreateDate { get; set; } = DateTime.UtcNow;
+}

src/Infrastructure/BotSharp.Abstraction/Infrastructures/MessageQueues/Models/MQPublishOptions.cs

@@ -0,0 +1,40 @@
+using System.Text.Json;
+
+namespace BotSharp.Abstraction.Infrastructures.MessageQueues.Models;
+
+/// <summary>
+/// Configuration options for publishing messages to a message queue.
+/// These options are MQ-product agnostic and can be adapted by different implementations.
+/// </summary>
+public class MQPublishOptions
+{
+    /// <summary>
+    /// The topic name (exchange in RabbitMQ, topic in Kafka/Azure Service Bus).
+    /// </summary>
+    public string TopicName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// The routing key (partition key in some MQ systems, used for message routing).
+    /// </summary>
+    public string RoutingKey { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Delay in milliseconds before the message is delivered.
+    /// </summary>
+    public long DelayMilliseconds { get; set; }
+
+    /// <summary>
+    /// Optional unique identifier for the message.
+    /// </summary>
+    public string? MessageId { get; set; }
+
+    /// <summary>
+    /// Additional arguments for the publish configuration (MQ-specific).
+    /// </summary>
+    public Dictionary<string, object?> Arguments { get; set; } = [];
+
+    /// <summary>
+    /// Json serializer options
+    /// </summary>
+    public JsonSerializerOptions? JsonOptions { get; set; }
+}

src/Infrastructure/BotSharp.Abstraction/Instructs/IInstructHook.cs

@@ -12,5 +12,5 @@ public interface IInstructHook : IHookBase
     Task OnResponseGenerated(InstructResponseModel response) => Task.CompletedTask;
 
     Task BeforeCodeExecution(Agent agent, CodeExecutionContext context) => Task.CompletedTask;
-    Task AfterCodeExecution(Agent agent, CodeExecutionResponseModel response) => Task.CompletedTask;
+    Task AfterCodeExecution(Agent agent, CodeExecutionContext context, CodeExecutionResponseModel response) => Task.CompletedTask;
 }

src/Infrastructure/BotSharp.Abstraction/Instructs/InstructHookBase.cs

@@ -28,7 +28,7 @@ public virtual async Task BeforeCodeExecution(Agent agent, CodeExecutionContext
         await Task.CompletedTask;
     }
 
-    public virtual async Task AfterCodeExecution(Agent agent, CodeExecutionResponseModel response)
+    public virtual async Task AfterCodeExecution(Agent agent, CodeExecutionContext context, CodeExecutionResponseModel response)
     {
         await Task.CompletedTask;
     }

src/Infrastructure/BotSharp.Abstraction/Rules/Hooks/IRuleTriggerHook.cs

@@ -0,0 +1,13 @@
+using BotSharp.Abstraction.Hooks;
+using BotSharp.Abstraction.Rules.Models;
+
+namespace BotSharp.Abstraction.Rules.Hooks;
+
+public interface IRuleTriggerHook : IHookBase
+{
+    Task BeforeRuleConditionExecuting(Agent agent, RuleNode conditionNode, IRuleTrigger trigger, RuleFlowContext context) => Task.CompletedTask;
+    Task AfterRuleConditionExecuted(Agent agent, RuleNode conditionNode, IRuleTrigger trigger, RuleFlowContext context, RuleNodeResult result) => Task.CompletedTask;
+
+    Task BeforeRuleActionExecuting(Agent agent, RuleNode actionNode, IRuleTrigger trigger, RuleFlowContext context) => Task.CompletedTask;
+    Task AfterRuleActionExecuted(Agent agent, RuleNode actionNode, IRuleTrigger trigger, RuleFlowContext context, RuleNodeResult result) => Task.CompletedTask;
+}

src/Infrastructure/BotSharp.Abstraction/Rules/IRuleAction.cs

@@ -1,5 +1,21 @@
+using BotSharp.Abstraction.Rules.Models;
+
 namespace BotSharp.Abstraction.Rules;
 
-public interface IRuleAction
+/// <summary>
+/// Base interface for rule actions that can be executed by the RuleEngine
+/// </summary>
+public interface IRuleAction : IRuleFlowUnit
 {
-}
+    /// <summary>
+    /// Execute the rule action
+    /// </summary>
+    /// <param name="agent">The agent that triggered the rule</param>
+    /// <param name="trigger">The rule trigger</param>
+    /// <param name="context">The flow context</param>
+    /// <returns>The action execution result</returns>
+    Task<RuleNodeResult> ExecuteAsync(
+        Agent agent,
+        IRuleTrigger trigger,
+        RuleFlowContext context);
+}

src/Infrastructure/BotSharp.Abstraction/Rules/IRuleCondition.cs

@@ -0,0 +1,22 @@
+using BotSharp.Abstraction.Rules.Models;
+
+namespace BotSharp.Abstraction.Rules;
+
+/// <summary>
+/// Base interface for rule conditions that can be evaluated by the RuleEngine
+/// </summary>
+public interface IRuleCondition : IRuleFlowUnit
+{
+    /// <summary>
+    /// Evaluate the rule condition
+    /// </summary>
+    /// <param name="agent">The agent that triggered the rule</param>
+    /// <param name="trigger">The rule trigger</param>
+    /// <param name="context">The flow context</param>
+    /// <returns>The condition evaluation result</returns>
+    Task<RuleNodeResult> EvaluateAsync(
+        Agent agent,
+        IRuleTrigger trigger,
+        RuleFlowContext context);
+}
+

src/Infrastructure/BotSharp.Abstraction/Rules/IRuleEngine.cs

@@ -1,3 +1,5 @@
+using BotSharp.Abstraction.Rules.Models;
+
 namespace BotSharp.Abstraction.Rules;
 
 public interface IRuleEngine
@@ -13,4 +15,15 @@ public interface IRuleEngine
     /// <exception cref="NotImplementedException"></exception>
     Task<IEnumerable<string>> Triggered(IRuleTrigger trigger, string text, IEnumerable<MessageState>? states = null, RuleTriggerOptions? options = null)
         => throw new NotImplementedException();
+
+    /// <summary>
+    /// Execute rule graph node
+    /// </summary>
+    /// <param name="node"></param>
+    /// <param name="graph"></param>
+    /// <param name="agentId"></param>
+    /// <param name="trigger"></param>
+    /// <param name="options"></param>
+    /// <returns></returns>
+    Task ExecuteGraphNode(RuleNode node, RuleGraph graph, string agentId, IRuleTrigger trigger, RuleNodeExecutionOptions options);
 }

src/Infrastructure/BotSharp.Abstraction/Rules/IRuleFlow.cs

@@ -0,0 +1,26 @@
+using BotSharp.Abstraction.Rules.Models;
+
+namespace BotSharp.Abstraction.Rules;
+
+public interface IRuleFlow<T> where T : class
+{
+    /// <summary>
+    /// Rule flow topology name
+    /// </summary>
+    string Name { get; }
+
+    /// <summary>
+    /// Get rule flow topology config 
+    /// </summary>
+    /// <param name="options"></param>
+    /// <returns></returns>
+    Task<RuleConfigModel> GetTopologyConfigAsync(RuleFlowConfigOptions? options = null);
+
+    /// <summary>
+    /// Get rule flow topology
+    /// </summary>
+    /// <param name="id"></param>
+    /// <param name="options"></param>
+    /// <returns></returns>
+    Task<T?> GetTopologyAsync(string id, RuleFlowLoadOptions? options = null);
+}

src/Infrastructure/BotSharp.Abstraction/Rules/IRuleFlowUnit.cs

@@ -0,0 +1,21 @@
+using BotSharp.Abstraction.Rules.Models;
+
+namespace BotSharp.Abstraction.Rules;
+
+public interface IRuleFlowUnit
+{
+    /// <summary>
+    /// The unique name of the rule flow unit, i.e., action, condition.
+    /// </summary>
+    string Name => string.Empty;
+
+    /// <summary>
+    /// The agent id
+    /// </summary>
+    string? AgentId => null;
+
+    /// <summary>
+    /// The trigger names
+    /// </summary>
+    IEnumerable<string>? Triggers => null;
+}

src/Infrastructure/BotSharp.Abstraction/Rules/Models/RuleConfigModel.cs

@@ -0,0 +1,10 @@
+using System.Text.Json;
+
+namespace BotSharp.Abstraction.Rules.Models;
+
+public class RuleConfigModel
+{
+    public string TopologyId { get; set; }
+    public string TopologyName { get; set; }
+    public JsonDocument CustomParameters { get; set; } = JsonDocument.Parse("{}");
+}

src/Infrastructure/BotSharp.Abstraction/Rules/Models/RuleFlowContext.cs

@@ -0,0 +1,18 @@
+using System.Text.Json;
+
+namespace BotSharp.Abstraction.Rules.Models;
+
+/// <summary>
+/// Context for rule flow execution (actions and conditions)
+/// </summary>
+public class RuleFlowContext
+{
+    public string Text { get; set; } = string.Empty;
+    public Dictionary<string, string?> Parameters { get; set; } = [];
+    public IEnumerable<RuleFlowStepResult> PrevStepResults { get; set; } = [];
+    public JsonSerializerOptions? JsonOptions { get; set; }
+    public RuleNode Node { get; set; }
+    public RuleEdge Edge { get; set; }
+    public RuleGraph Graph { get; set; }
+}
+