diff --git a/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Components/Pages/Home.razor b/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Components/Pages/Home.razor
index c12c34409..b072c3ef0 100644
--- a/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Components/Pages/Home.razor
+++ b/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Components/Pages/Home.razor
@@ -1,4 +1,4 @@
-@page "/"
+@page "/"
 
 @using Amazon.Lambda.TestTool.Commands
 @using Amazon.Lambda.TestTool.Services
@@ -9,7 +9,7 @@
 @using Microsoft.AspNetCore.Http;
 
 @inject IHttpContextAccessor HttpContextAccessor
-@inject IRuntimeApiDataStore RuntimeApiModel
+@inject IRuntimeApiDataStoreManager DataStoreManager
 @inject IDirectoryManager DirectoryManager
 
 <PageTitle>Lambda Function Tester</PageTitle>
@@ -62,33 +62,33 @@
     </div>
     <div class="col-sm-6">
         <h3>Active Event:</h3>
-        @if (RuntimeApiModel.ActiveEvent == null)
+        @if (DataStore.ActiveEvent == null)
         {
             <h2>No active event</h2>
         }
         else
         {
             <div>
-                <div style="cursor: pointer" @onclick="() => OnRequeue(RuntimeApiModel.ActiveEvent.AwsRequestId)">
+                <div style="cursor: pointer" @onclick="() => OnRequeue(DataStore.ActiveEvent.AwsRequestId)">
                     @((MarkupString)RebootIcon)
                 </div>
-                <p><b>Request ID:</b> @RuntimeApiModel.ActiveEvent.AwsRequestId</p>
-                <p><b>Status:</b> <span style="@GetStatusStyle(RuntimeApiModel.ActiveEvent.EventStatus)">@RuntimeApiModel.ActiveEvent.EventStatus</span></p>
-                <p><b>Last Updated:</b> @RuntimeApiModel.ActiveEvent.LastUpdated</p>
-                <p><b>Event JSON:</b><span class="event-value"><span class="fake-link" @onclick="() => ShowEventJson(RuntimeApiModel.ActiveEvent)">@CreateSnippet(RuntimeApiModel.ActiveEvent.EventJson)</span></span></p>
-                @if (RuntimeApiModel.ActiveEvent.EventStatus == EventContainer.Status.Failure)
+                <p><b>Request ID:</b> @DataStore.ActiveEvent.AwsRequestId</p>
+                <p><b>Status:</b> <span style="@GetStatusStyle(DataStore.ActiveEvent.EventStatus)">@DataStore.ActiveEvent.EventStatus</span></p>
+                <p><b>Last Updated:</b> @DataStore.ActiveEvent.LastUpdated</p>
+                <p><b>Event JSON:</b><span class="event-value"><span class="fake-link" @onclick="() => ShowEventJson(DataStore.ActiveEvent)">@CreateSnippet(DataStore.ActiveEvent.EventJson)</span></span></p>
+                @if (DataStore.ActiveEvent.EventStatus == EventContainer.Status.Failure)
                 {
-                    <p><b>Error Type:</b> @RuntimeApiModel.ActiveEvent.ErrorType</p>
+                    <p><b>Error Type:</b> @DataStore.ActiveEvent.ErrorType</p>
                     <p>
                         <b>Error Response:</b>
-                        <pre class="form-control" style="@Constants.ResponseErrorStyleSizeConstraint">@RuntimeApiModel.ActiveEvent.ErrorResponse</pre>
+                        <pre class="form-control" style="@Constants.ResponseErrorStyleSizeConstraint">@DataStore.ActiveEvent.ErrorResponse</pre>
                     </p>
                 }
                 else
                 {
                     <p>
                         <b>Response:</b>
-                        <pre class="form-control" style="@Constants.ResponseSuccessStyleSizeConstraint">@Utils.TryPrettyPrintJson(RuntimeApiModel.ActiveEvent.Response)</pre>
+                        <pre class="form-control" style="@Constants.ResponseSuccessStyleSizeConstraint">@Utils.TryPrettyPrintJson(DataStore.ActiveEvent.Response)</pre>
                     </p>
                 }
             </div>
@@ -101,7 +101,7 @@
     <div class="col-sm-6">
         <h3>Queued Events: <button class="btn btn-secondary btn-sm" @onclick="OnClearQueued">Clear</button></h3>
         <div class="col-xs-5 event-list">
-            @foreach (var evnt in @RuntimeApiModel.QueuedEvents)
+            @foreach (var evnt in @DataStore.QueuedEvents)
             {
                 <div class="event-list-item">
                     <div class="row" style="padding: 2px">
@@ -123,7 +123,7 @@
     <div class="col-sm-6">
         <h3>Executed Events: <button class="btn btn-secondary btn-sm" @onclick="OnClearExecuted">Clear</button></h3>
         <div class="col-xs-5 event-list">
-            @foreach (var evnt in @RuntimeApiModel.ExecutedEvents.OrderByDescending(x => x.LastUpdated))
+            @foreach (var evnt in @DataStore.ExecutedEvents.OrderByDescending(x => x.LastUpdated))
             {
                 <div class="event-list-item">
                     <div class="row" style="padding: 2px">
@@ -189,6 +189,8 @@
 
     private IDictionary<string, IList<LambdaRequest>> SampleRequests { get; set; } = new Dictionary<string, IList<LambdaRequest>>();
 
+    private IRuntimeApiDataStore DataStore => DataStoreManager.GetLambdaRuntimeDataStore(LambdaRuntimeApi.DefaultFunctionName);
+
     string? _selectedSampleRequestName;
     string? SelectedSampleRequestName
     {
@@ -218,19 +220,19 @@
 
     protected override void OnInitialized()
     {
-        RuntimeApiModel.StateChange += RuntimeApiModelOnStateChange;
+        DataStore.StateChange += DataStoreOnStateChange;
         SampleRequestManager = new SampleRequestManager(DirectoryManager.GetCurrentDirectory());
         SampleRequests = SampleRequestManager.GetSampleRequests();
     }
 
-    private void RuntimeApiModelOnStateChange(object? sender, EventArgs e)
+    private void DataStoreOnStateChange(object? sender, EventArgs e)
     {
         InvokeAsync(this.StateHasChanged);
     }
 
     void OnAddEventClick()
     {
-        RuntimeApiModel.QueueEvent(FunctionInput);
+        DataStore.QueueEvent(FunctionInput, false);
         FunctionInput = "";
         SelectedSampleRequestName = NoSampleSelectedId;
         StateHasChanged();
@@ -238,38 +240,38 @@
 
     void OnClearQueued()
     {
-        RuntimeApiModel.ClearQueued();
+        DataStore.ClearQueued();
         StateHasChanged();
     }
 
     void OnClearExecuted()
     {
-        RuntimeApiModel.ClearExecuted();
+        DataStore.ClearExecuted();
         StateHasChanged();
     }
 
     void OnRequeue(string awsRequestId)
     {
         EventContainer? evnt = null;
-        if (string.Equals(RuntimeApiModel.ActiveEvent?.AwsRequestId, awsRequestId))
+        if (string.Equals(DataStore.ActiveEvent?.AwsRequestId, awsRequestId))
         {
-            evnt = RuntimeApiModel.ActiveEvent;
+            evnt = DataStore.ActiveEvent;
         }
         else
         {
-            evnt = RuntimeApiModel.ExecutedEvents.FirstOrDefault(x => string.Equals(x.AwsRequestId, awsRequestId));
+            evnt = DataStore.ExecutedEvents.FirstOrDefault(x => string.Equals(x.AwsRequestId, awsRequestId));
         }
 
         if (evnt == null)
             return;
 
-        RuntimeApiModel.QueueEvent(evnt.EventJson);
+        DataStore.QueueEvent(evnt.EventJson, false);
         StateHasChanged();
     }
 
     void OnDeleteEvent(string awsRequestId)
     {
-        RuntimeApiModel.DeleteEvent(awsRequestId);
+        DataStore.DeleteEvent(awsRequestId);
         StateHasChanged();
     }
 
diff --git a/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Models/EventContainer.cs b/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Models/EventContainer.cs
index bf7da1603..366cb2a17 100644
--- a/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Models/EventContainer.cs
+++ b/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Models/EventContainer.cs
@@ -1,11 +1,11 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
 using Amazon.Lambda.TestTool.Services;
 
 namespace Amazon.Lambda.TestTool.Models;
 
-public class EventContainer
+public class EventContainer : IDisposable
 {
     public enum Status { Queued, Executing, Success, Failure }
 
@@ -21,6 +21,9 @@ public enum Status { Queued, Executing, Success, Failure }
     public DateTime LastUpdated { get; private set; }
 
     private Status _status = Status.Queued;
+
+    private ManualResetEventSlim? _resetEvent;
+
     public Status EventStatus
     {
         get => _status;
@@ -33,12 +36,17 @@ public Status EventStatus
 
     private readonly RuntimeApiDataStore _dataStore;
 
-    public EventContainer(RuntimeApiDataStore dataStore, int eventCount, string eventJson)
+    public EventContainer(RuntimeApiDataStore dataStore, int eventCount, string eventJson, bool isRequestResponseMode)
     {
         LastUpdated = DateTime.Now;
         _dataStore = dataStore;
         AwsRequestId = eventCount.ToString("D12");
         EventJson = eventJson;
+
+        if (isRequestResponseMode)
+        {
+            _resetEvent = new ManualResetEventSlim(false);
+        }
     }
 
     public string FunctionArn
@@ -51,6 +59,12 @@ public void ReportSuccessResponse(string response)
         LastUpdated = DateTime.Now;
         Response = response;
         EventStatus = Status.Success;
+
+        if (_resetEvent != null)
+        {
+            _resetEvent.Set();
+        }
+
         _dataStore.RaiseStateChanged();
     }
 
@@ -60,6 +74,50 @@ public void ReportErrorResponse(string errorType, string errorBody)
         ErrorType = errorType;
         ErrorResponse = errorBody;
         EventStatus = Status.Failure;
+
+        if (_resetEvent != null)
+        {
+            _resetEvent.Set();
+        }
+
         _dataStore.RaiseStateChanged();
     }
+
+    public bool WaitForCompletion()
+    {
+        if (_resetEvent == null)
+        {
+            return false;
+        }
+
+        // The 15 minutes is a fail safe so we at some point we unblock the thread. It is intentionally
+        // long to give the user time to debug the Lambda function.
+        return _resetEvent.Wait(TimeSpan.FromMinutes(15));
+    }
+
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    private bool _disposed = false;
+    protected virtual void Dispose(bool disposing)
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        if (disposing)
+        {
+            if (_resetEvent != null)
+            {
+                _resetEvent.Dispose();
+                _resetEvent = null;
+            }
+        }
+
+        _disposed = true;
+    }
 }
diff --git a/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Processes/TestToolProcess.cs b/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Processes/TestToolProcess.cs
index 2fd66beaf..d78027cb8 100644
--- a/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Processes/TestToolProcess.cs
+++ b/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Processes/TestToolProcess.cs
@@ -1,4 +1,4 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
 using Amazon.Lambda.TestTool.Commands.Settings;
@@ -37,7 +37,7 @@ public static TestToolProcess Startup(RunCommandSettings settings, CancellationT
     {
         var builder = WebApplication.CreateBuilder();
 
-        builder.Services.AddSingleton<IRuntimeApiDataStore, RuntimeApiDataStore>();
+        builder.Services.AddSingleton<IRuntimeApiDataStoreManager, RuntimeApiDataStoreManager>();
 
         // Add services to the container.
         builder.Services.AddRazorComponents()
@@ -65,7 +65,7 @@ public static TestToolProcess Startup(RunCommandSettings settings, CancellationT
         app.MapRazorComponents<App>()
             .AddInteractiveServerRenderMode();
 
-        _ = new LambdaRuntimeApi(app, app.Services.GetService<IRuntimeApiDataStore>()!);
+        LambdaRuntimeApi.SetupLambdaRuntimeApiEndpoints(app);
 
         var runTask = app.RunAsync(cancellationToken);
 
diff --git a/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Services/LambdaRuntimeAPI.cs b/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Services/LambdaRuntimeAPI.cs
index 3fc0ccfcc..fc088d186 100644
--- a/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Services/LambdaRuntimeAPI.cs
+++ b/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Services/LambdaRuntimeAPI.cs
@@ -1,28 +1,24 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+using System.Collections.Concurrent;
 using System.Text;
 using Amazon.Lambda.TestTool.Models;
 using Microsoft.AspNetCore.Mvc;
 
-// TODO:
-// Make IRuntimeApiDataStore separate the events per function name
-// When PostEvent being syncronous when X-Amz-Invocation-Type header is not set or set to RequestResponse.
-//          https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html#lambda-Invoke-request-InvocationType
-
-
 namespace Amazon.Lambda.TestTool.Services;
 
 public class LambdaRuntimeApi
 {
-    private const string DefaultFunctionName = "__DefaultFunction__";
+    internal const string DefaultFunctionName = "__DefaultFunction__";
     private const string HeaderBreak = "-----------------------------------";
 
-    private readonly IRuntimeApiDataStore _runtimeApiDataStore;
+    private readonly IRuntimeApiDataStoreManager _runtimeApiDataStoreManager;
 
-    public LambdaRuntimeApi(WebApplication app, IRuntimeApiDataStore runtimeApiDataStore)
+    private LambdaRuntimeApi(WebApplication app)
     {
-        _runtimeApiDataStore = runtimeApiDataStore;
+        _runtimeApiDataStoreManager = app.Services.GetRequiredService<IRuntimeApiDataStoreManager>();
+
         app.MapPost("/2015-03-31/functions/function/invocations", (Delegate)PostEventDefaultFunction);
         app.MapPost("/2015-03-31/functions/{functionName}/invocations", PostEvent);
 
@@ -39,18 +35,51 @@ public LambdaRuntimeApi(WebApplication app, IRuntimeApiDataStore runtimeApiDataS
         app.MapPost("/{functionName}/2018-06-01/runtime/invocation/{awsRequestId}/error", PostError);
     }
 
-    public Task<IResult> PostEventDefaultFunction(HttpContext ctx)
+    public static void SetupLambdaRuntimeApiEndpoints(WebApplication app)
+    {
+        _ = new LambdaRuntimeApi(app);
+    }
+
+    public Task PostEventDefaultFunction(HttpContext ctx)
     {
         return PostEvent(ctx, DefaultFunctionName);
     }
 
-    public async Task<IResult> PostEvent(HttpContext ctx, string functionName)
+    public async Task PostEvent(HttpContext ctx, string functionName)
     {
+        var runtimeDataStore = _runtimeApiDataStoreManager.GetLambdaRuntimeDataStore(functionName);
+
+        // RequestResponse mode is the default when invoking with the Lambda service client.
+        var isRequestResponseMode = true;
+        if (ctx.Request.Headers.TryGetValue("X-Amz-Invocation-Type", out var invocationType))
+        {
+            isRequestResponseMode = string.Equals(invocationType, "RequestResponse", StringComparison.InvariantCulture);
+        }
+
         using var reader = new StreamReader(ctx.Request.Body);
         var testEvent = await reader.ReadToEndAsync();
-        _runtimeApiDataStore.QueueEvent(testEvent);
+        var evnt = runtimeDataStore.QueueEvent(testEvent, isRequestResponseMode);
 
-        return Results.Accepted();
+        if (isRequestResponseMode)
+        {
+            evnt.WaitForCompletion();
+            var result = Results.Ok(evnt.Response);
+            ctx.Response.StatusCode = 200;
+
+            if (!string.IsNullOrEmpty(evnt.Response))
+            {
+                var responseData = Encoding.UTF8.GetBytes(evnt.Response);
+                ctx.Response.Headers.ContentType = "application/json";
+                ctx.Response.Headers.ContentLength = responseData.Length;
+
+                await ctx.Response.Body.WriteAsync(responseData);
+            }
+            evnt.Dispose();
+        }
+        else
+        {
+            ctx.Response.StatusCode = 202;
+        }
     }
 
     public Task GetNextInvocationDefaultFunction(HttpContext ctx)
@@ -60,8 +89,10 @@ public Task GetNextInvocationDefaultFunction(HttpContext ctx)
 
     public async Task GetNextInvocation(HttpContext ctx, string functionName)
     {
+        var runtimeDataStore = _runtimeApiDataStoreManager.GetLambdaRuntimeDataStore(functionName);
+
         EventContainer? activeEvent;
-        while (!_runtimeApiDataStore.TryActivateEvent(out activeEvent))
+        while (!runtimeDataStore.TryActivateEvent(out activeEvent))
         {
             await Task.Delay(TimeSpan.FromMilliseconds(100));
         }
@@ -72,6 +103,7 @@ public async Task GetNextInvocation(HttpContext ctx, string functionName)
         Console.WriteLine(HeaderBreak);
         Console.WriteLine($"Next invocation returned: {activeEvent.AwsRequestId}");
 
+
         ctx.Response.Headers["Lambda-Runtime-Aws-Request-Id"] = activeEvent.AwsRequestId;
         ctx.Response.Headers["Lambda-Runtime-Trace-Id"] = Guid.NewGuid().ToString();
         ctx.Response.Headers["Lambda-Runtime-Invoked-Function-Arn"] = activeEvent.FunctionArn;
@@ -109,10 +141,12 @@ public Task<IResult> PostInvocationResponseDefaultFunction(HttpContext ctx, stri
 
     public async Task<IResult> PostInvocationResponse(HttpContext ctx, string functionName, string awsRequestId)
     {
+        var runtimeDataStore = _runtimeApiDataStoreManager.GetLambdaRuntimeDataStore(functionName);
+
         using var reader = new StreamReader(ctx.Request.Body);
         var response = await reader.ReadToEndAsync();
 
-        _runtimeApiDataStore.ReportSuccess(awsRequestId, response);
+        runtimeDataStore.ReportSuccess(awsRequestId, response);
 
         Console.WriteLine(HeaderBreak);
         Console.WriteLine($"Response for request {awsRequestId}");
@@ -128,10 +162,12 @@ public Task<IResult> PostErrorDefaultFunction(HttpContext ctx, string awsRequest
 
     public async Task<IResult> PostError(HttpContext ctx, string functionName, string awsRequestId, [FromHeader(Name = "Lambda-Runtime-Function-Error-Type")] string errorType)
     {
+        var runtimeDataStore = _runtimeApiDataStoreManager.GetLambdaRuntimeDataStore(functionName);
+
         using var reader = new StreamReader(ctx.Request.Body);
         var errorBody = await reader.ReadToEndAsync();
 
-        _runtimeApiDataStore.ReportError(awsRequestId, errorType, errorBody);
+        runtimeDataStore.ReportError(awsRequestId, errorType, errorBody);
         await Console.Error.WriteLineAsync(HeaderBreak);
         await Console.Error.WriteLineAsync($"Request {awsRequestId} Error Type: {errorType}");
         await Console.Error.WriteLineAsync(errorBody);
diff --git a/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Services/RuntimeApiDataStore.cs b/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Services/RuntimeApiDataStore.cs
index 7b2172b30..1329c6e35 100644
--- a/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Services/RuntimeApiDataStore.cs
+++ b/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Services/RuntimeApiDataStore.cs
@@ -6,43 +6,91 @@
 
 namespace Amazon.Lambda.TestTool.Services;
 
+/// <summary>
+/// The runtime API data store is used to hold the queued, executed and active Lambda events for Lambda function.
+/// </summary>
 public interface IRuntimeApiDataStore
 {
-    EventContainer QueueEvent(string eventBody);
-
+    /// <summary>
+    /// Queue the event for a Lambda function to process.
+    /// </summary>
+    /// <param name="eventBody">The Lambda event body.</param>
+    /// <param name="isRequestResponseMode">If the event is for a request response mode thread syncronization code will be activated to all the response to be return for the request.</param>
+    /// <returns></returns>
+    EventContainer QueueEvent(string eventBody, bool isRequestResponseMode);
+
+    /// <summary>
+    /// The list of queued events.
+    /// </summary>
     IReadOnlyList<EventContainer> QueuedEvents { get; }
 
+    /// <summary>
+    /// The list of executed events.
+    /// </summary>
     IReadOnlyList<EventContainer> ExecutedEvents { get; }
 
+    /// <summary>
+    /// Clear the list of queued events.
+    /// </summary>
     void ClearQueued();
 
+    /// <summary>
+    /// Clear the list of executed events.
+    /// </summary>
     void ClearExecuted();
 
     void DeleteEvent(string awsRequestId);
 
-
+    /// <summary>
+    /// The active event a Lambda function has pulled from the queue and is currently processing.
+    /// </summary>
     EventContainer? ActiveEvent { get; }
 
+    /// <summary>
+    /// An event that some event or event collection has changed. This is used by the UI to
+    /// know when it should refresh.
+    /// </summary>
     event EventHandler? StateChange;
 
+    /// <summary>
+    /// Try to activate an event by grabbing the latest event from the queue.
+    /// </summary>
+    /// <param name="activeEvent"></param>
+    /// <returns></returns>
     bool TryActivateEvent(out EventContainer? activeEvent);
 
+    /// <summary>
+    /// Report the event was successfully processed. Used by the Lambda Runtime API when it gets
+    /// notification from the Lambda function.
+    /// </summary>
+    /// <param name="awsRequestId"></param>
+    /// <param name="response"></param>
     void ReportSuccess(string awsRequestId, string response);
+
+    /// <summary>
+    /// Report the processing the event failed. Used by the Lambda Runtime API when it gets
+    /// notification from the Lambda function.
+    /// </summary>
+    /// <param name="awsRequestId"></param>
+    /// <param name="response"></param>
     void ReportError(string awsRequestId, string errorType, string errorBody);
 }
 
+/// <inheritdoc/>
 public class RuntimeApiDataStore : IRuntimeApiDataStore
 {
-    private IList<EventContainer> _queuedEvents = new List<EventContainer>();
-    private IList<EventContainer> _executedEvents = new List<EventContainer>();
+    private readonly IList<EventContainer> _queuedEvents = new List<EventContainer>();
+    private readonly IList<EventContainer> _executedEvents = new List<EventContainer>();
     private int _eventCounter = 1;
-    private object _lock = new object();
+    private readonly object _lock = new object();
 
+    /// <inheritdoc/>
     public event EventHandler? StateChange;
 
-    public EventContainer QueueEvent(string eventBody)
+    /// <inheritdoc/>
+    public EventContainer QueueEvent(string eventBody, bool isRequestResponseMode)
     {
-        var evnt = new EventContainer(this, _eventCounter++, eventBody);
+        var evnt = new EventContainer(this, _eventCounter++, eventBody, isRequestResponseMode);
         lock (_lock)
         {
             _queuedEvents.Add(evnt);
@@ -52,6 +100,7 @@ public EventContainer QueueEvent(string eventBody)
         return evnt;
     }
 
+    /// <inheritdoc/>
     public bool TryActivateEvent(out EventContainer? activeEvent)
     {
         activeEvent = null;
@@ -81,8 +130,10 @@ public bool TryActivateEvent(out EventContainer? activeEvent)
         }
     }
 
+    /// <inheritdoc/>
     public EventContainer? ActiveEvent { get; private set; }
 
+    /// <inheritdoc/>
     public IReadOnlyList<EventContainer> QueuedEvents
     {
         get
@@ -94,6 +145,7 @@ public IReadOnlyList<EventContainer> QueuedEvents
         }
     }
 
+    /// <inheritdoc/>
     public IReadOnlyList<EventContainer> ExecutedEvents
     {
         get
@@ -105,6 +157,7 @@ public IReadOnlyList<EventContainer> ExecutedEvents
         }
     }
 
+    /// <inheritdoc/>
     public void ReportSuccess(string awsRequestId, string response)
     {
         lock(_lock)
@@ -120,6 +173,7 @@ public void ReportSuccess(string awsRequestId, string response)
         RaiseStateChanged();
     }
 
+    /// <inheritdoc/>
     public void ReportError(string awsRequestId, string errorType, string errorBody)
     {
         lock(_lock)
@@ -135,6 +189,7 @@ public void ReportError(string awsRequestId, string errorType, string errorBody)
         RaiseStateChanged();
     }
 
+    /// <inheritdoc/>
     public void ClearQueued()
     {
         lock(_lock)
@@ -144,6 +199,7 @@ public void ClearQueued()
         RaiseStateChanged();
     }
 
+    /// <inheritdoc/>
     public void ClearExecuted()
     {
         lock(_lock)
@@ -153,6 +209,7 @@ public void ClearExecuted()
         RaiseStateChanged();
     }
 
+    /// <inheritdoc/>
     public void DeleteEvent(string awsRequestId)
     {
         lock(_lock)
diff --git a/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Services/RuntimeApiDataStoreManager.cs b/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Services/RuntimeApiDataStoreManager.cs
new file mode 100644
index 000000000..c78377ecf
--- /dev/null
+++ b/Tools/LambdaTestTool-v2/src/Amazon.Lambda.TestTool/Services/RuntimeApiDataStoreManager.cs
@@ -0,0 +1,41 @@
+using System.Collections.Concurrent;
+
+namespace Amazon.Lambda.TestTool.Services;
+
+/// <summary>
+/// The runtime api data store manager is used to partition the Lambda events per Lambda function using the Lambda runtime api.
+/// </summary>
+public interface IRuntimeApiDataStoreManager
+{
+    /// <summary>
+    /// Gets the IRuntimeApiDataStore for the Lambda function
+    /// </summary>
+    /// <param name="functionName"></param>
+    /// <returns></returns>
+    IRuntimeApiDataStore GetLambdaRuntimeDataStore(string functionName);
+
+    /// <summary>
+    /// Gets the list of lambda functions. For each Lambda function that calls into Lambda runtime api the GetLambdaRuntimeDataStore is
+    /// called creating a data store. This method returns that list of functions that have had a data store created.
+    /// </summary>
+    /// <returns></returns>
+    string[] GetListOfFunctionNames();
+}
+
+/// <inheritdoc/>
+internal class RuntimeApiDataStoreManager : IRuntimeApiDataStoreManager
+{
+    private readonly ConcurrentDictionary<string, IRuntimeApiDataStore> _dataStores = new ConcurrentDictionary<string, IRuntimeApiDataStore>();
+
+    /// <inheritdoc/>
+    public IRuntimeApiDataStore GetLambdaRuntimeDataStore(string functionName)
+    {
+        return _dataStores.GetOrAdd(functionName, name => new RuntimeApiDataStore());
+    }
+
+    /// <inheritdoc/>
+    public string[] GetListOfFunctionNames()
+    {
+        return _dataStores.Keys.ToArray();
+    }
+}
diff --git a/Tools/LambdaTestTool-v2/tests/Amazon.Lambda.TestTool.UnitTests/Properties/AssemblyInfo.cs b/Tools/LambdaTestTool-v2/tests/Amazon.Lambda.TestTool.UnitTests/Properties/AssemblyInfo.cs
new file mode 100644
index 000000000..a821f1dfb
--- /dev/null
+++ b/Tools/LambdaTestTool-v2/tests/Amazon.Lambda.TestTool.UnitTests/Properties/AssemblyInfo.cs
@@ -0,0 +1,2 @@
+
+[assembly: Xunit.CollectionBehavior(DisableTestParallelization = true)]
\ No newline at end of file
diff --git a/Tools/LambdaTestTool-v2/tests/Amazon.Lambda.TestTool.UnitTests/RuntimeApiTests.cs b/Tools/LambdaTestTool-v2/tests/Amazon.Lambda.TestTool.UnitTests/RuntimeApiTests.cs
index d9346e0c2..8befe6e0d 100644
--- a/Tools/LambdaTestTool-v2/tests/Amazon.Lambda.TestTool.UnitTests/RuntimeApiTests.cs
+++ b/Tools/LambdaTestTool-v2/tests/Amazon.Lambda.TestTool.UnitTests/RuntimeApiTests.cs
@@ -9,20 +9,17 @@
 using Amazon.Lambda.Core;
 using Amazon.Lambda.TestTool.Processes;
 using Amazon.Lambda.TestTool.Commands.Settings;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Amazon.Lambda.TestTool.UnitTests;
 
 public class RuntimeApiTests
 {
-    public RuntimeApiTests()
-    {
-        // Set this environment variable so anytime we start the LambdaBootstrap from RuntimeSupport it exists after processing an event.
-        System.Environment.SetEnvironmentVariable("AWS_LAMBDA_DOTNET_DEBUG_RUN_ONCE", "true");
-    }
-
     [Fact]
     public async Task AddEventToDataStore()
     {
+        const string functionName = "FunctionFoo";
+
         var cancellationTokenSource = new CancellationTokenSource();
         var options = new RunCommandSettings();
         options.Port = 9000;
@@ -32,15 +29,19 @@ public async Task AddEventToDataStore()
             var lambdaClient = ConstructLambdaServiceClient(testToolProcess.ServiceUrl);
             var invokeFunction = new InvokeRequest
             {
-                FunctionName = "FunctionFoo",
-                Payload = "\"hello\""
+                FunctionName = functionName,
+                Payload = "\"hello\"",
+                InvocationType = InvocationType.Event
             };
 
             await lambdaClient.InvokeAsync(invokeFunction);
 
-            var dataStore = testToolProcess.Services.GetService(typeof(IRuntimeApiDataStore)) as IRuntimeApiDataStore;
+            var dataStoreManager = testToolProcess.Services.GetRequiredService<IRuntimeApiDataStoreManager>();
+            var dataStore = dataStoreManager.GetLambdaRuntimeDataStore(functionName);
             Assert.NotNull(dataStore);
             Assert.Single(dataStore.QueuedEvents);
+            Assert.Single(dataStoreManager.GetListOfFunctionNames());
+            Assert.Equal(functionName, dataStoreManager.GetListOfFunctionNames().First());
 
             var handlerCalled = false;
             var handler = (string input, ILambdaContext context) =>
@@ -49,25 +50,80 @@ public async Task AddEventToDataStore()
                 return input.ToUpper();
             };
 
-            System.Environment.SetEnvironmentVariable("AWS_LAMBDA_RUNTIME_API", $"{options.Host}:{options.Port}");
-            await LambdaBootstrapBuilder.Create(handler, new DefaultLambdaJsonSerializer())
+            System.Environment.SetEnvironmentVariable("AWS_LAMBDA_RUNTIME_API", $"{options.Host}:{options.Port}/{functionName}");
+            _ = LambdaBootstrapBuilder.Create(handler, new DefaultLambdaJsonSerializer())
                     .Build()
-                    .RunAsync();
+                    .RunAsync(cancellationTokenSource.Token);
 
+            await Task.Delay(2000);
             Assert.True(handlerCalled);
         }
         finally
         {
             await cancellationTokenSource.CancelAsync();
-            await testToolProcess.RunningTask;
         }
     }
 
+    [Fact]
+    public async Task InvokeRequestResponse()
+    {
+        const string functionName = "FunctionFoo";
+
+        var cancellationTokenSource = new CancellationTokenSource();
+        var options = new RunCommandSettings();
+        options.Port = 9001;
+        var testToolProcess = TestToolProcess.Startup(options, cancellationTokenSource.Token);
+        try
+        {
+            var handler = (string input, ILambdaContext context) =>
+            {
+                Thread.Sleep(1000); // Add a sleep to prove the LambdaRuntimeApi waited for the completion.
+                return input.ToUpper();
+            };
+
+            System.Environment.SetEnvironmentVariable("AWS_LAMBDA_RUNTIME_API", $"{options.Host}:{options.Port}/{functionName}");
+            _ = LambdaBootstrapBuilder.Create(handler, new DefaultLambdaJsonSerializer())
+                    .Build()
+                    .RunAsync(cancellationTokenSource.Token);
+
+            var lambdaClient = ConstructLambdaServiceClient(testToolProcess.ServiceUrl);
+
+            // Test with relying on the default value of InvocationType
+            var invokeFunction = new InvokeRequest
+            {
+                FunctionName = functionName,
+                Payload = "\"hello\""
+            };
+
+            var response = await lambdaClient.InvokeAsync(invokeFunction);
+            var responsePayloadString = System.Text.Encoding.Default.GetString(response.Payload.ToArray());
+            Assert.Equal("\"HELLO\"", responsePayloadString);
+
+            // Test with InvocationType explicilty set
+            invokeFunction = new InvokeRequest
+            {
+                FunctionName = functionName,
+                Payload = "\"hello\"",
+                InvocationType = InvocationType.RequestResponse
+            };
+
+            response = await lambdaClient.InvokeAsync(invokeFunction);
+            responsePayloadString = System.Text.Encoding.Default.GetString(response.Payload.ToArray());
+            Assert.Equal("\"HELLO\"", responsePayloadString);
+        }
+        finally
+        {
+            await cancellationTokenSource.CancelAsync();
+        }
+
+    }
+
     private IAmazonLambda ConstructLambdaServiceClient(string url)
     {
         var config = new AmazonLambdaConfig
         {
-            ServiceURL = url
+            ServiceURL = url,
+            MaxErrorRetry = 0
         };
 
         // We don't need real credentials because we are not calling the real Lambda service.