feat(Infrastructure): add in-memory thread persistence service

Implemented IThreadPersistenceService with in-memory storage
for AI Agent threads. This allows for saving, retrieving, and
deleting serialized thread data.

Modified files (3):
- IThreadPersistenceService.cs: Added interface definition
- InMemoryThreadPersistenceService.cs: Implemented in-memory logic
- DependencyInjection.cs: Registered in-memory service for DI

Author: cristofima

TaskAgent.Application/Interfaces/IThreadPersistenceService.cs

@@ -0,0 +1,27 @@
+namespace TaskAgent.Application.Interfaces;
+
+/// <summary>
+/// Service for persisting and retrieving AI Agent threads
+/// </summary>
+public interface IThreadPersistenceService
+{
+    /// <summary>
+    /// Saves a serialized thread to storage
+    /// </summary>
+    /// <param name="threadId">Unique identifier for the thread</param>
+    /// <param name="serializedThread">Serialized thread data</param>
+    Task SaveThreadAsync(string threadId, string serializedThread);
+
+    /// <summary>
+    /// Retrieves a serialized thread from storage
+    /// </summary>
+    /// <param name="threadId">Unique identifier for the thread</param>
+    /// <returns>Serialized thread data, or null if not found</returns>
+    Task<string?> GetThreadAsync(string threadId);
+
+    /// <summary>
+    /// Deletes a thread from storage
+    /// </summary>
+    /// <param name="threadId">Unique identifier for the thread</param>
+    Task DeleteThreadAsync(string threadId);
+}

TaskAgent.Infrastructure/DependencyInjection.cs

@@ -25,6 +25,9 @@ IConfiguration configuration
 
         services.AddScoped<ITaskRepository, TaskRepository>();
 
+        // For production: replace with Redis/SQL implementation and use Scoped/Transient
+        services.AddSingleton<IThreadPersistenceService, InMemoryThreadPersistenceService>();
+
         RegisterContentSafety(services, configuration);
 
         return services;

TaskAgent.Infrastructure/Services/InMemoryThreadPersistenceService.cs

@@ -0,0 +1,57 @@
+using System.Collections.Concurrent;
+using TaskAgent.Application.Interfaces;
+
+namespace TaskAgent.Infrastructure.Services;
+
+/// <summary>
+/// In-memory implementation of thread persistence
+/// Simple implementation for single-server scenarios
+/// </summary>
+public class InMemoryThreadPersistenceService : IThreadPersistenceService
+{
+    private readonly ConcurrentDictionary<string, string> _threads = new();
+
+    public Task SaveThreadAsync(string threadId, string serializedThread)
+    {
+        if (string.IsNullOrWhiteSpace(threadId))
+        {
+            throw new ArgumentException("Thread ID cannot be empty", nameof(threadId));
+        }
+
+        if (string.IsNullOrWhiteSpace(serializedThread))
+        {
+            throw new ArgumentException(
+                "Serialized thread cannot be empty",
+                nameof(serializedThread)
+            );
+        }
+
+        _threads[threadId] = serializedThread;
+
+        return Task.CompletedTask;
+    }
+
+    public Task<string?> GetThreadAsync(string threadId)
+    {
+        if (string.IsNullOrWhiteSpace(threadId))
+        {
+            return Task.FromResult<string?>(null);
+        }
+
+        _threads.TryGetValue(threadId, out string? serializedThread);
+
+        return Task.FromResult(serializedThread);
+    }
+
+    public Task DeleteThreadAsync(string threadId)
+    {
+        if (string.IsNullOrWhiteSpace(threadId))
+        {
+            return Task.CompletedTask;
+        }
+
+        _threads.TryRemove(threadId, out _);
+
+        return Task.CompletedTask;
+    }
+}

TaskAgent.WebApp/DependencyInjection.cs

@@ -50,8 +50,9 @@ private static void RegisterTaskAgent(IServiceCollection services, IConfiguratio
         {
             ITaskRepository taskRepository = sp.GetRequiredService<ITaskRepository>();
             ILogger<TaskAgentService> logger = sp.GetRequiredService<ILogger<TaskAgentService>>();
+            IThreadPersistenceService threadPersistence = sp.GetRequiredService<IThreadPersistenceService>();
             AIAgent agent = TaskAgentService.CreateAgent(client, modelDeployment, taskRepository);
-            return new TaskAgentService(agent, logger);
+            return new TaskAgentService(agent, logger, threadPersistence);
         });
     }
 }

TaskAgent.WebApp/Services/TaskAgentService.cs

@@ -3,24 +3,30 @@
 using Microsoft.Extensions.AI;
 using OpenAI;
 using OpenAI.Chat;
+using System.Text.Json;
 using TaskAgent.Application.Functions;
 using TaskAgent.Application.Interfaces;
 
 namespace TaskAgent.WebApp.Services;
 
 /// <summary>
-/// Service for managing AI Agent lifecycle and interactions
+/// Service for managing AI Agent lifecycle and interactions.
+/// Uses thread persistence to maintain conversation context across requests.
 /// </summary>
 public class TaskAgentService : ITaskAgentService
 {
     private readonly AIAgent _agent;
-    private readonly Dictionary<string, object> _threads = new();
     private readonly ILogger<TaskAgentService> _logger;
+    private readonly IThreadPersistenceService _threadPersistence;
 
-    public TaskAgentService(AIAgent agent, ILogger<TaskAgentService> logger)
+    public TaskAgentService(
+        AIAgent agent,
+        ILogger<TaskAgentService> logger,
+        IThreadPersistenceService threadPersistence)
     {
         _agent = agent ?? throw new ArgumentNullException(nameof(agent));
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        _threadPersistence = threadPersistence ?? throw new ArgumentNullException(nameof(threadPersistence));
     }
 
     /// <summary>
@@ -194,44 +200,80 @@ When showing task details (single task):
         );
     }
 
-    public async Task<string> SendMessageAsync(string message, string threadId)
+    public async Task<(string response, string threadId)> SendMessageAsync(
+        string message,
+        string? threadId = null
+    )
     {
         if (string.IsNullOrWhiteSpace(message))
         {
             throw new ArgumentException("Message cannot be empty", nameof(message));
         }
 
-        if (string.IsNullOrWhiteSpace(threadId))
+        // For Chat Completion agents, conversation history is IN THE THREAD OBJECT
+        // We serialize/deserialize it to maintain context across stateless HTTP requests
+        AgentThread thread;
+        string activeThreadId;
+
+        if (!string.IsNullOrWhiteSpace(threadId))
         {
-            throw new ArgumentException("Thread ID cannot be empty", nameof(threadId));
+            // Try to restore previous conversation
+            string? serializedThread = await _threadPersistence.GetThreadAsync(threadId);
+
+            if (serializedThread != null)
+            {
+                // Deserialize existing thread to continue conversation
+                JsonElement threadJson = JsonSerializer.Deserialize<JsonElement>(serializedThread);
+                thread = _agent.DeserializeThread(threadJson);
+                activeThreadId = threadId;
+            }
+            else
+            {
+                // Thread not found - create new one but keep the threadId
+                thread = _agent.GetNewThread();
+                activeThreadId = threadId;
+                _logger.LogWarning("ThreadId {ThreadId} not found in storage, creating new thread", threadId);
+            }
         }
-
-        // Get existing thread or use the one passed in
-        if (!_threads.TryGetValue(threadId, out object? thread))
+        else
         {
-            throw new ArgumentException(
-                $"Thread ID '{threadId}' not found. Create a thread first using GetNewThreadId()",
-                nameof(threadId)
-            );
+            // First message - create new thread
+            thread = _agent.GetNewThread();
+            activeThreadId = Guid.NewGuid().ToString();
         }
 
         try
         {
+            // Run the agent with the thread
             dynamic? response = await _agent.RunAsync(message, (dynamic)thread);
-            string? responseText = response.Text;
-            return responseText ?? "I'm sorry, I couldn't process that request.";
+            string? responseText = response?.Text;
+
+            // Serialize and persist the updated thread for next request
+            JsonElement serializedThread = thread.Serialize();
+            string serializedJson = JsonSerializer.Serialize(
+                serializedThread,
+                JsonSerializerOptions.Web
+            );
+            await _threadPersistence.SaveThreadAsync(activeThreadId, serializedJson);
+
+            return (
+                responseText ?? "I'm sorry, I couldn't process that request.",
+                activeThreadId
+            );
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Error in agent execution");
-            return $"An error occurred while processing your request: {ex.Message}";
+            _logger.LogError(ex, "Error in agent execution for thread {ThreadId}", activeThreadId);
+            return (
+                $"An error occurred while processing your request: {ex.Message}",
+                activeThreadId
+            );
         }
     }
 
     public string GetNewThreadId()
     {
-        string threadId = Guid.NewGuid().ToString();
-        _threads[threadId] = _agent.GetNewThread();
-        return threadId;
+        // Simply return a new GUID - client manages thread persistence
+        return Guid.NewGuid().ToString();
     }
 }