You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Converted all synchronous MongoDB operations to async equivalents (e.g., UpdateOne to UpdateOneAsync, InsertMany to InsertManyAsync, DeleteMany to DeleteManyAsync)
Updated method signatures to return Task, Task, or Task instead of void or direct return types
Added await keywords for all async MongoDB driver calls
Replaced LINQ queries with async-compatible MongoDB filter builders
Below is a summary of compliance checks for this PR:
Security Compliance
⚪
Path traversal
Description: Multiple new/modified async code paths build file system paths using potentially user-controlled identifiers (e.g., agentId, templateName, ci.Channel, func.Name) in Path.Combine(...) and then read/write/delete via File.*Async (e.g., writing instruction/template/response files and reading templates/responses), which could permit path traversal or arbitrary file overwrite/read if those inputs are not strictly validated/sanitized elsewhere (e.g., values containing .., directory separators, or absolute paths). FileRepository.Agent.cs [365-792]
Referred Code
// Save default instructionsvarinstructionFile=Path.Combine(instructionDir,$"{AGENT_INSTRUCTION_FILE}.{_agentSettings.TemplateFormat}");awaitFile.WriteAllTextAsync(instructionFile,instruction??string.Empty);awaitTask.Delay(50);// Save channel instructionsforeach(varciinchannelInstructions){if(string.IsNullOrWhiteSpace(ci.Channel)){continue;}varfile=Path.Combine(instructionDir,$"{AGENT_INSTRUCTION_FILE}.{ci.Channel}.{_agentSettings.TemplateFormat}");awaitFile.WriteAllTextAsync(file,ci.Instruction??string.Empty);awaitTask.Delay(50);}}privateasyncTaskUpdateAgentFunctions(stringagentId,List<FunctionDef>inputFunctions)
...(clipped 407lines)
Ticket Compliance
⚪
🎫 No ticket provided
Create ticket/issue
Codebase Duplication Compliance
⚪
Codebase context is not defined
Follow the guide to enable codebase context checks.
Custom Compliance
🟢
Generic: Secure Error Handling
Objective: To prevent the leakage of sensitive system information through error messages while providing sufficient detail for internal debugging.
Generic: Meaningful Naming and Self-Documenting Code
Objective: Ensure all identifiers clearly express their purpose and intent, making code self-documenting
Status: Misspelled method name: The newly async method name MigrateConvsersationLatestStates contains a spelling error, reducing readability and self-documentation.
Generic: Robust Error Handling and Edge Case Management
Objective: Ensure comprehensive error handling that provides meaningful context and graceful degradation
Status: Unhandled file I/O: New async file reads/writes (e.g., reading convFile directly) are performed without existence checks or exception handling, which can throw and fail without actionable context.
Objective: To create a detailed and reliable record of critical system actions for security analysis and compliance.
Status: Missing audit logs: Critical destructive operations (bulk delete of agent-related collections and per-agent deletes) are executed without any visible audit logging of actor, action, and outcome in the changed code.
Generic: Security-First Input Validation and Data Handling
Objective: Ensure all data inputs are validated, sanitized, and handled securely to prevent vulnerabilities
Status: Path input hardening: The changed async code continues to build filesystem paths directly from external identifiers (e.g., agentId) without visible normalization/validation, which may require verification against upstream constraints to prevent path traversal risks.
Referred Code
// Save default instructionsvarinstructionFile=Path.Combine(instructionDir,$"{AGENT_INSTRUCTION_FILE}.{_agentSettings.TemplateFormat}");awaitFile.WriteAllTextAsync(instructionFile,instruction??string.Empty);awaitTask.Delay(50);// Save channel instructionsforeach(varciinchannelInstructions){if(string.IsNullOrWhiteSpace(ci.Channel)){continue;}varfile=Path.Combine(instructionDir,$"{AGENT_INSTRUCTION_FILE}.{ci.Channel}.{_agentSettings.TemplateFormat}");awaitFile.WriteAllTextAsync(file,ci.Instruction??string.Empty);awaitTask.Delay(50);}}privateasyncTaskUpdateAgentFunctions(stringagentId,List<FunctionDef>inputFunctions)
...(clipped 157lines)
Why: The suggestion correctly identifies and fixes invalid C# syntax ([] for an empty list) that was introduced in the PR and would cause a compilation error.
High
Avoid blocking on async in Dispose
Avoid blocking on an async method in Dispose by removing the call to Save(). This prevents a "sync over async" anti-pattern that can cause deadlocks.
public void Dispose()
{
- Save().ConfigureAwait(false).GetAwaiter().GetResult();+ // Avoid calling async methods from Dispose.+ // The Save() method should be called and awaited+ // by the consumer of this service before disposal.
}
Apply / Chat
Suggestion importance[1-10]: 9
__
Why: The suggestion correctly identifies a "sync over async" anti-pattern in the Dispose method, which was introduced in the PR and can cause application deadlocks.
High
Avoid blocking on async database calls
Fix a "sync over async" anti-pattern by converting GetRoutingRecords and GetRoutableAgents to async methods and using await for the db.GetAgents call to prevent deadlocks.
[To ensure code accuracy, apply this suggestion manually]
Suggestion importance[1-10]: 9
__
Why: The suggestion correctly identifies a critical "sync over async" anti-pattern introduced in the PR that can cause deadlocks, and it provides the correct fix.
High
Use await instead of blocking calls
Replace the blocking .ConfigureAwait(false).GetAwaiter().GetResult() call with await inside the SetState and RemoveState methods to prevent potential deadlocks.
[To ensure code accuracy, apply this suggestion manually]
Suggestion importance[1-10]: 9
__
Why: The suggestion correctly identifies a critical "sync over async" anti-pattern introduced in the PR that can cause deadlocks, and it provides the correct fix.
High
Avoid blocking calls in observer
Replace the blocking .GetAwaiter().GetResult() call in the OnNext method with Task.Run to execute the asynchronous storage.Append operation in the background, avoiding potential deadlocks.
Why: The suggestion correctly identifies a "sync over async" call (.GetAwaiter().GetResult()) introduced in the PR, which can cause deadlocks, and provides a valid solution using Task.Run to prevent blocking the observer thread.
High
Use aggregation pipeline for efficient joins
Replace the inefficient client-side LINQ join in GetUserAgents with a more performant server-side MongoDB aggregation pipeline using $lookup.
public async Task<List<UserAgent>> GetUserAgents(string userId)
{
- var found = await (from ua in _dc.UserAgents.AsQueryable()- join u in _dc.Users.AsQueryable() on ua.UserId equals u.Id- where ua.UserId == userId || u.ExternalId == userId- select ua).ToListAsync();+ var userAgentCollection = _dc.GetCollection<UserAgentDocument>("UserAgent");+ var userCollection = _dc.GetCollection<UserDocument>("User");++ var found = await userAgentCollection.Aggregate()+ .Lookup(+ foreignCollection: userCollection,+ localField: "UserId",+ foreignField: "_id",+ @as: "Users"+ )+ .Match(new BsonDocument+ {+ { "$or", new BsonArray+ {+ new BsonDocument("UserId", userId),+ new BsonDocument("Users.ExternalId", userId)+ }+ }+ })+ .As<UserAgentDocument>()+ .ToListAsync();
if (found.IsNullOrEmpty())
{
return new List<UserAgent>();
}
var res = found.Select(ua => new UserAgent
{
Id = ua.Id,
UserId = ua.UserId,
AgentId = ua.AgentId,
CreatedTime = ua.CreatedTime,
UpdatedTime = ua.UpdatedTime
}).ToList();
var agentIds = found.Select(x => x.AgentId).Distinct().ToList();
var agents = await GetAgents(new AgentFilter { AgentIds = agentIds });
foreach (var item in res)
{
var agent = agents.FirstOrDefault(x => x.Id == item.AgentId);
if (agent == null) continue;
item.Editable = agent.IsPublic;
item.Agent = agent;
}
return res;
}
[To ensure code accuracy, apply this suggestion manually]
Suggestion importance[1-10]: 8
__
Why: The suggestion correctly points out a significant performance issue with client-side joins and proposes using a server-side aggregation pipeline ($lookup), which is the standard and much more efficient way to perform joins in MongoDB.
Medium
General
Add semaphore to GetDialogs
To prevent race conditions, wrap the logic inside the GetDialogs method with the same SemaphoreSlim used in the Append method, ensuring thread-safe read/write access.
public async Task<List<RoleDialogModel>> GetDialogs(string conversationId)
{
- var db = _services.GetRequiredService<IBotSharpRepository>();- var dialogs = await db.GetConversationDialogs(conversationId);- ...- return results;+ await _semaphore.WaitAsync();+ try+ {+ var db = _services.GetRequiredService<IBotSharpRepository>();+ var dialogs = await db.GetConversationDialogs(conversationId);+ ...+ return results;+ }+ finally+ {+ _semaphore.Release();+ }
}
[To ensure code accuracy, apply this suggestion manually]
Suggestion importance[1-10]: 8
__
Why: The suggestion correctly points out a potential race condition where GetDialogs could read data while Append is writing, and proposes using the existing semaphore to ensure thread safety.
Medium
✅ Simplify logic by removing unnecessary loopSuggestion Impact:The commit refactored/simplified the query logic inside the existing loop by removing the verbose MongoDB FilterBuilder/orFilters construction and replacing it with a single LINQ predicate. However, it did not implement the core part of the suggestion: the while loop and pagination (Skip/Take) remain.
code diff:
@@ -560,45 +561,14 @@
while (true)
{
var skip = (page - 1) * batchSize;
- var builder = Builders<ConversationDocument>.Filter;- var filters = new List<FilterDefinition<ConversationDocument>>();-- // Build the OR condition: (!excludeAgentIds.Contains(AgentId) && DialogCount <= messageLimit) - // || (excludeAgentIds.Contains(AgentId) && DialogCount == 0)- var orFilters = new List<FilterDefinition<ConversationDocument>>();-- // First condition: !excludeAgentIds.Contains(AgentId) && DialogCount <= messageLimit- if (excludeAgentIdsList.Any())- {- orFilters.Add(builder.And(- builder.Nin(x => x.AgentId, excludeAgentIdsList),- builder.Lte(x => x.DialogCount, messageLimit)- ));- }- else- {- // If excludeAgentIds is empty, all agents match the first condition- orFilters.Add(builder.Lte(x => x.DialogCount, messageLimit));- }-- // Second condition: excludeAgentIds.Contains(AgentId) && DialogCount == 0- if (excludeAgentIdsList.Any())- {- orFilters.Add(builder.And(- builder.In(x => x.AgentId, excludeAgentIdsList),- builder.Eq(x => x.DialogCount, 0)- ));- }-- filters.Add(builder.Or(orFilters));- filters.Add(builder.Lte(x => x.UpdatedTime, utcNow.AddHours(-bufferHours)));-- var filter = builder.And(filters);- var candidates = await _dc.Conversations.Find(filter)- .Skip(skip)- .Limit(batchSize)- .Project(x => x.Id)- .ToListAsync();+ var candidates = await _dc.Conversations.AsQueryable()+ .Where(x => ((!excludeAgentIds.Contains(x.AgentId) && x.DialogCount <= messageLimit)+ || (excludeAgentIds.Contains(x.AgentId) && x.DialogCount == 0))+ && x.UpdatedTime <= utcNow.AddHours(-bufferHours))+ .Skip(skip)+ .Take(batchSize)+ .Select(x => x.Id)+ .ToListAsync();
Simplify the GetIdleConversations method by removing the unnecessary while loop and pagination logic, using a single database query with Limit instead.
public async Task<List<string>> GetIdleConversations(int batchSize, int messageLimit, int bufferHours, IEnumerable<string> excludeAgentIds)
{
- var page = 1;
var batchLimit = 100;
var utcNow = DateTime.UtcNow;
- var conversationIds = new List<string>();
var excludeAgentIdsList = excludeAgentIds?.ToList() ?? new List<string>();
if (batchSize <= 0 || batchSize > batchLimit)
{
batchSize = batchLimit;
}
- while (true)+ var builder = Builders<ConversationDocument>.Filter;+ var filters = new List<FilterDefinition<ConversationDocument>>();++ // Build the OR condition: (!excludeAgentIds.Contains(AgentId) && DialogCount <= messageLimit) + // || (excludeAgentIds.Contains(AgentId) && DialogCount == 0)+ var orFilters = new List<FilterDefinition<ConversationDocument>>();++ // First condition: !excludeAgentIds.Contains(AgentId) && DialogCount <= messageLimit+ if (excludeAgentIdsList.Any())
{
- var skip = (page - 1) * batchSize;- var builder = Builders<ConversationDocument>.Filter;- var filters = new List<FilterDefinition<ConversationDocument>>();-- // Build the OR condition: (!excludeAgentIds.Contains(AgentId) && DialogCount <= messageLimit) - // || (excludeAgentIds.Contains(AgentId) && DialogCount == 0)- var orFilters = new List<FilterDefinition<ConversationDocument>>();-- // First condition: !excludeAgentIds.Contains(AgentId) && DialogCount <= messageLimit- if (excludeAgentIdsList.Any())- {- orFilters.Add(builder.And(- builder.Nin(x => x.AgentId, excludeAgentIdsList),- builder.Lte(x => x.DialogCount, messageLimit)- ));- }- else- {- // If excludeAgentIds is empty, all agents match the first condition- orFilters.Add(builder.Lte(x => x.DialogCount, messageLimit));- }-- // Second condition: excludeAgentIds.Contains(AgentId) && DialogCount == 0- if (excludeAgentIdsList.Any())- {- orFilters.Add(builder.And(- builder.In(x => x.AgentId, excludeAgentIdsList),- builder.Eq(x => x.DialogCount, 0)- ));- }-- filters.Add(builder.Or(orFilters));- filters.Add(builder.Lte(x => x.UpdatedTime, utcNow.AddHours(-bufferHours)));-- var filter = builder.And(filters);- var candidates = await _dc.Conversations.Find(filter)- .Skip(skip)- .Limit(batchSize)- .Project(x => x.Id)- .ToListAsync();-- if (candidates.IsNullOrEmpty())- {- break;- }-- conversationIds.AddRange(candidates);- if (conversationIds.Count >= batchSize)- {- break;- }- page++;+ orFilters.Add(builder.And(+ builder.Nin(x => x.AgentId, excludeAgentIdsList),+ builder.Lte(x => x.DialogCount, messageLimit)+ ));+ }+ else+ {+ // If excludeAgentIds is empty, all agents match the first condition+ orFilters.Add(builder.Lte(x => x.DialogCount, messageLimit));
}
- return conversationIds.Take(batchSize).ToList();+ // Second condition: excludeAgentIds.Contains(AgentId) && DialogCount == 0+ if (excludeAgentIdsList.Any())+ {+ orFilters.Add(builder.And(+ builder.In(x => x.AgentId, excludeAgentIdsList),+ builder.Eq(x => x.DialogCount, 0)+ ));+ }++ filters.Add(builder.Or(orFilters));+ filters.Add(builder.Lte(x => x.UpdatedTime, utcNow.AddHours(-bufferHours)));++ var filter = builder.And(filters);+ var conversationIds = await _dc.Conversations.Find(filter)+ .Limit(batchSize)+ .Project(x => x.Id)+ .ToListAsync();++ return conversationIds;
}
[To ensure code accuracy, apply this suggestion manually]
Suggestion importance[1-10]: 7
__
Why: The suggestion correctly identifies that the while loop is unnecessary and inefficient, replacing multiple potential database queries with a single, simpler query that achieves the same result.
Medium
Avoid capturing context
Add .ConfigureAwait(false) to all asynchronous file and I/O operations to avoid capturing the synchronization context and reduce the risk of deadlocks.
Why: The suggestion provides a best practice for library code to prevent potential deadlocks in consuming applications by using .ConfigureAwait(false) on async I/O operations.
Low
Execute independent async tasks concurrently
Improve performance by executing independent OnStateLoaded hook calls concurrently using Task.WhenAll instead of awaiting them sequentially in a loop.
var hooks = _services.GetHooks<IConversationHook>(_routingContext.GetCurrentAgentId());
-foreach (var hook in hooks)-{- await hook.OnStateLoaded(_curStates);-}+var tasks = hooks.Select(hook => hook.OnStateLoaded(_curStates));+await Task.WhenAll(tasks);
Apply / Chat
Suggestion importance[1-10]: 6
__
Why: The suggestion proposes a valid performance optimization by running independent hook operations concurrently using Task.WhenAll, which is a good practice for improving asynchronous code.
Low
Learned best practice
Guard semaphore release with flag
Guard _dialogLock.Release() with an acquired flag so the semaphore is released only if WaitAsync() succeeded, preventing incorrect releases on exceptions before acquisition.
-await _dialogLock.WaitAsync();+var acquired = false;
try
{
+ await _dialogLock.WaitAsync();+ acquired = true;+
if (!File.Exists(dialogDir))
{
return dialogs;
}
var texts = await File.ReadAllTextAsync(dialogDir);
try
{
dialogs = JsonSerializer.Deserialize<List<DialogElement>>(texts, _options) ?? new List<DialogElement>();
}
catch
{
dialogs = new List<DialogElement>();
}
}
finally
{
- _dialogLock.Release();+ if (acquired) _dialogLock.Release();
}
Apply / Chat
Suggestion importance[1-10]: 6
__
Why:
Relevant best practice - Ensure semaphores are only released when successfully acquired (use an acquired flag in a try/finally) to avoid double-release or releasing without acquisition on exceptions.
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
PR Type
Enhancement
Description
Comprehensive conversion of synchronous methods to async/await pattern across the entire codebase
Converted all repository implementations (FileRepository and MongoRepository) to use async methods for database and file I/O operations
Replaced synchronous MongoDB operations with async equivalents (
UpdateOneAsync,InsertManyAsync,DeleteManyAsync, etc.)Replaced synchronous file I/O operations with async versions (
File.WriteAllTextAsync,File.ReadAllTextAsync, etc.)Replaced
Thread.Sleep()calls withawait Task.Delay()for non-blocking delaysReplaced
lockstatements withSemaphoreSlimfor thread-safe async operations in conversation managementUpdated all interface signatures in
IBotSharpRepositoryandIConversationServiceto returnTask,Task<T>, orTask<bool>Updated service layer methods across ConversationService, AgentService, RoleService, and other services to properly await async repository calls
Updated controller methods to use
awaitfor async service operationsUpdated plugin and hook implementations to properly handle async method calls
Removed unnecessary
.ConfigureAwait(false).GetAwaiter().GetResult()calls and replaced with properawaitsyntaxDiagram Walkthrough
File Walkthrough
51 files
FileRepository.Agent.cs
Convert FileRepository Agent methods to async operationssrc/Infrastructure/BotSharp.Core/Repository/FileRepository/FileRepository.Agent.cs
Taskmethods withawaitkeywords
File.WriteAllText,File.ReadAllText,File.WriteAllLines) with async equivalents(
File.WriteAllTextAsync,File.ReadAllTextAsync,File.WriteAllLinesAsync)Thread.Sleep()calls withawait Task.Delay()for non-blockingdelays
Task,Task, orTaskinstead ofvoidor direct return typesMongoRepository.Agent.cs
Convert MongoRepository Agent methods to async operationssrc/Plugins/BotSharp.Plugin.MongoStorage/Repository/MongoRepository.Agent.cs
(e.g.,
UpdateOnetoUpdateOneAsync,InsertManytoInsertManyAsync,DeleteManytoDeleteManyAsync)Task,Task, orTaskinstead ofvoidor direct return typesawaitkeywords for all async MongoDB driver callsFileRepository.Conversation.cs
Convert FileRepository Conversation methods to async operationssrc/Infrastructure/BotSharp.Core/Repository/FileRepository/FileRepository.Conversation.cs
throughout conversation management methods
lockstatements withSemaphoreSlimfor thread-safe asyncoperations on
_dialogLockand_stateLockTask,Task, orTaskinstead ofvoidor direct return typesThread.Sleep()withawait Task.Delay()for non-blockingdelays
MongoRepository.Conversation.cs
Convert MongoRepository Conversation methods to async operationssrc/Plugins/BotSharp.Plugin.MongoStorage/Repository/MongoRepository.Conversation.cs
awaitkeywordsTask,Task, orTaskinstead ofvoidor direct return typesand aggregation pipelines
GetIdleConversationsto use MongoDB filter builders insteadof LINQ for better async support
IBotSharpRepository.cs
Update IBotSharpRepository interface signatures to asyncsrc/Infrastructure/BotSharp.Abstraction/Repositories/IBotSharpRepository.cs
Task,Task, orTaskinstead of
voidor direct return typesstatistics, translations, and knowledge base operations
NotImplementedExceptionimplementations
StreamingLogHook.cs
Convert StreamingLogHook methods to async operationssrc/Plugins/BotSharp.Plugin.ChatHub/Hooks/StreamingLogHook.cs
BuildContentLogandBuildStateLogmethods to asyncTaskmethods
awaitkeywordSaveConversationContentLogandSaveConversationStateLogcallsto use
awaitfor async repository operationsConversationService.cs
Update ConversationService to use async repository methodssrc/Infrastructure/BotSharp.Core/Conversations/Services/ConversationService.cs
awaitfor async repository operations(
DeleteConversations,UpdateConversationTitle,UpdateConversationTags,etc.)
GetDialogHistoryandSetConversationIdto async methods withawaitkeywordsGetAgentMessageCountandSaveStatesto async methodsawaitfor async state loading and dialog retrieval operationsFileRepository.KnowledgeBase.cs
Convert FileRepository KnowledgeBase methods to async operationssrc/Infrastructure/BotSharp.Core/Repository/FileRepository/FileRepository.KnowledgeBase.cs
(
File.WriteAllTextAsync,File.ReadAllTextAsync)Taskinstead ofboolawaitkeywords for all async file operationsMongoRepository.Role.cs
MongoDB Role repository methods converted to asyncsrc/Plugins/BotSharp.Plugin.MongoStorage/Repository/MongoRepository.Role.cs
RefreshRoles,GetRoles,GetRoleDetails, andUpdateRolemethods to async by adding
async Taskreturn typesDeleteMany,InsertMany,Find().ToList(),UpdateOne) with their async counterparts(
DeleteManyAsync,InsertManyAsync,ToListAsync,UpdateOneAsync)awaitkeywords for all async MongoDB callsFileRepository.Log.cs
File repository log methods converted to asyncsrc/Infrastructure/BotSharp.Core/Repository/FileRepository/FileRepository.Log.cs
SaveLlmCompletionLog,SaveConversationContentLog,GetConversationContentLogs,SaveConversationStateLog,GetConversationStateLogs) to asyncFile.WriteAllText,File.ReadAllText) with async versions (File.WriteAllTextAsync,File.ReadAllTextAsync)awaitkeywords for all async file operationsFileRepository.Role.cs
File repository role methods converted to asyncsrc/Infrastructure/BotSharp.Core/Repository/FileRepository/FileRepository.Role.cs
Taskreturn typesThread.Sleep(50)withawait Task.Delay(50)for async delaysFile.WriteAllTextAsync)Task.FromResult()for consistencyPluginLoader.cs
Plugin loader methods converted to asyncsrc/Infrastructure/BotSharp.Core/Plugins/PluginLoader.cs
GetPlugins,GetPagedPlugins, andUpdatePluginStatusmethodsto async
await.ConfigureAwait(false).GetAwaiter().GetResult()calls and using properawaitMongoRepository.Log.cs
MongoDB log repository methods converted to asyncsrc/Plugins/BotSharp.Plugin.MongoStorage/Repository/MongoRepository.Log.cs
Taskreturn types(
InsertOneAsync,FirstOrDefaultAsync,ToListAsync)awaitkeywords for all async MongoDB callsConversationStateService.cs
Conversation state service methods converted to asyncsrc/Infrastructure/BotSharp.Core/Conversations/Services/ConversationStateService.cs
LoadandSavemethods to async withTaskreturn typesawait.Wait()calls to properawaitsyntax for async operationsDisposemethod to use.ConfigureAwait(false).GetAwaiter().GetResult()for async cleanupMongoRepository.KnowledgeBase.cs
MongoDB knowledge base repository methods converted to asyncsrc/Plugins/BotSharp.Plugin.MongoStorage/Repository/MongoRepository.KnowledgeBase.cs
(
DeleteManyAsync,InsertManyAsync,ReplaceOneAsync,ToListAsync)awaitkeywords for all async database callsMongoRepository.AgentTask.cs
MongoDB agent task repository methods converted to asyncsrc/Plugins/BotSharp.Plugin.MongoStorage/Repository/MongoRepository.AgentTask.cs
Taskreturn types(
FirstOrDefaultAsync,InsertOneAsync,InsertManyAsync,ReplaceOneAsync,DeleteManyAsync)async Taskinstead ofvoidfor asyncoperations
FileRepository.AgentTask.cs
File repository agent task methods converted to asyncsrc/Infrastructure/BotSharp.Core/Repository/FileRepository/FileRepository.AgentTask.cs
Taskreturn types(
File.WriteAllTextAsync)BulkInsertAgentTasksmethod with proper async iterationTask.FromResult()for consistencyAgentService.Coding.cs
Agent service coding methods updated for async callssrc/Infrastructure/BotSharp.Core/Agents/Services/AgentService.Coding.cs
awaitfor async database operationsTask.FromResult()wrappersFileRepository.Stats.cs
File repository stats methods converted to asyncsrc/Infrastructure/BotSharp.Core/Repository/FileRepository/FileRepository.Stats.cs
Taskreturn types(
File.ReadAllTextAsync,File.WriteAllTextAsync)awaitkeywords for all async file operationsEvaluatingService.Evaluate.cs
Evaluation service methods converted to asyncsrc/Infrastructure/BotSharp.Core/Evaluations/Services/EvaluatingService.Evaluate.cs
GetInitialStatesmethod to async withTaskreturn typeawaitfor async repository operationsFileRepository.Crontab.cs
File repository crontab methods converted to asyncsrc/Infrastructure/BotSharp.Core/Repository/FileRepository/FileRepository.Crontab.cs
Taskreturn types(
File.WriteAllTextAsync,File.ReadAllTextAsync)Task.FromResult()for consistencyConversationStorage.cs
Conversation storage methods converted to async with semaphoresrc/Infrastructure/BotSharp.Core/Conversations/Services/ConversationStorage.cs
AppendandGetDialogsmethods to async withTaskreturntypes
SemaphoreSlimfor async-safesynchronization
awaitfor async repository operationsBotSharpConversationSideCar.cs
Conversation sidecar methods converted to asyncsrc/Infrastructure/BotSharp.Core.SideCar/Services/BotSharpConversationSideCar.cs
Taskreturntypes
await Task.CompletedTaskfor methods that don't perform actualasync operations
TaskorTaskinstead ofvoidMongoRepository.Translation.cs
MongoDB translation repository methods converted to asyncsrc/Plugins/BotSharp.Plugin.MongoStorage/Repository/MongoRepository.Translation.cs
Taskreturn types(
ToListAsync,InsertManyAsync,ReplaceOneAsync)Thread.Sleep(50)withawait Task.Delay(50)for async delaysMongoRepository.AgentCodeScript.cs
MongoDB agent code script repository methods converted to asyncsrc/Plugins/BotSharp.Plugin.MongoStorage/Repository/MongoRepository.AgentCodeScript.cs
Taskreturn types(
BulkWriteAsync,InsertManyAsync,DeleteManyAsync)awaitkeywords for all async database callsConversationController.cs
Conversation controller methods updated for async callssrc/Infrastructure/BotSharp.OpenAPI/Controllers/Conversation/ConversationController.cs
awaitfor async servicecalls
SetConversationIdandGetDialogHistorycalls to async withawaitFileRepository.Translation.cs
File repository translation methods converted to asyncsrc/Infrastructure/BotSharp.Core/Repository/FileRepository/FileRepository.Translation.cs
Taskreturn types(
File.ReadAllTextAsync,File.WriteAllTextAsync)awaitkeywords for all async file operationsTwilioMessageQueueService.cs
Twilio message queue service methods converted to asyncsrc/Plugins/BotSharp.Plugin.Twilio/Services/TwilioMessageQueueService.cs
Taskreturn typesawaitfor async service operationsGetDialogHistoryto async equivalentsFileRepository.AgentCodeScript.cs
File repository agent code script methods converted to asyncsrc/Infrastructure/BotSharp.Core/Repository/FileRepository/FileRepository.AgentCodeScript.cs
Taskreturn types(
File.WriteAllTextAsync)Task.FromResult()for consistencyRealtimeHub.cs
Realtime hub methods updated for async callssrc/Infrastructure/BotSharp.Core.Realtime/Services/RealtimeHub.cs
awaitfor async service operationsSetConversationId,GetDialogHistory, andAppendcalls to asyncwith
awaitRoleService.cs
Role service methods updated for async callssrc/Infrastructure/BotSharp.Core/Roles/Services/RoleService.cs
awaitfor async repository operationsGetRoleOptionsto returnTask>instead ofasync TaskConversationService.Migration.cs
Conversation migration service methods updated for async callssrc/Infrastructure/BotSharp.Core/Conversations/Services/ConversationService.Migration.cs
awaitfor async repository operationsAgentService.GetAgents.cs
Agent service GetAgents methods updated for async callssrc/Infrastructure/BotSharp.Core/Agents/Services/AgentService.GetAgents.cs
awaitfor async repository and serviceoperations
GetAgentsandGetPlugincalls to async withawaitIConversationService.cs
Conversation service interface methods converted to asyncsrc/Infrastructure/BotSharp.Abstraction/Conversations/IConversationService.cs
Taskfor asyncoperations
SetConversationId,GetDialogHistory, andSaveStatesto asyncPlotChartFn.cs
Chart handler function methods converted to asyncsrc/Plugins/BotSharp.Plugin.ChartHandler/Functions/PlotChartFn.cs
Taskreturn typeawaitfor async repository and serviceoperations
GetDialogHistoryandGetAgentTemplatecalls to async withawaitPyProgrammerFn.cs
Python interpreter function methods converted to asyncsrc/Plugins/BotSharp.Plugin.PythonInterpreter/Functions/PyProgrammerFn.cs
Taskreturn typeawaitfor async repository and serviceoperations
GetDialogHistoryandGetAgentTemplatecalls to async withawaitAgentTaskService.cs
Agent task service methods updated for async callssrc/Infrastructure/BotSharp.Core/Tasks/Services/AgentTaskService.cs
awaitfor async repository operationsTask.FromResult()wrappersPluginController.cs
Plugin controller methods updated for async callssrc/Infrastructure/BotSharp.OpenAPI/Controllers/Setting/PluginController.cs
awaitfor async plugin loaderoperations
GetPagedPluginsandGetPluginscalls to async withawaitSqlDriverController.cs
SQL driver controller methods updated for async callssrc/Plugins/BotSharp.Plugin.SqlDriver/Controllers/SqlDriverController.cs
awaitfor async service operationsSetConversationIdandAppendcalls to async withawaitMongoRepository.Crontab.cs
MongoDB crontab repository methods converted to asyncsrc/Plugins/BotSharp.Plugin.MongoStorage/Repository/MongoRepository.Crontab.cs
Taskreturn types(
ReplaceOneAsync,DeleteManyAsync)awaitkeywords for all async database callsTokenStatsConversationHook.cs
Convert AddToken to async method callsrc/Infrastructure/BotSharp.Logger/Hooks/TokenStatsConversationHook.cs
AddTokenmethod call to useawaitkeyword, making it properlyasynchronous
await Task.CompletedTaskstatementoperation
ReadImageFn.cs
Add await to GetDialogHistory async callsrc/Plugins/BotSharp.Plugin.ImageHandler/Functions/ReadImageFn.cs
awaitkeyword toGetDialogHistory()method callAgentService.cs
Add await to GetUserAgents database callsrc/Infrastructure/BotSharp.Core/Agents/Services/AgentService.cs
awaitkeyword to_db.GetUserAgents()method callReadPdfFn.cs
Add await to GetDialogHistory async callsrc/Plugins/BotSharp.Plugin.FileHandler/Functions/ReadPdfFn.cs
awaitkeyword toGetDialogHistory()method callReadAudioFn.cs
Add await to GetDialogHistory async callsrc/Plugins/BotSharp.Plugin.AudioHandler/Functions/ReadAudioFn.cs
awaitkeyword toGetDialogHistory()method callReadExcelFn.cs
Add await to GetDialogHistory async callsrc/Plugins/BotSharp.Plugin.ExcelHandler/Functions/ReadExcelFn.cs
awaitkeyword toGetDialogHistory()method callWelcomeHook.cs
Add await to storage Append async callsrc/Plugins/BotSharp.Plugin.ChatHub/Hooks/WelcomeHook.cs
awaitkeyword to_storage.Append()method callWebIntelligentSearchFn.cs
Add await to GetDialogHistory async callsrc/Infrastructure/BotSharp.Core/WebSearch/Functions/WebIntelligentSearchFn.cs
awaitkeyword toGetDialogHistory()method callIBotSharpStatsService.cs
Convert UpdateStats interface to async methodsrc/Infrastructure/BotSharp.Abstraction/Statistics/Services/IBotSharpStatsService.cs
UpdateStatsmethod signature to returnTaskinstead ofboolISettingService.cs
Convert GetDetail interface to async methodsrc/Infrastructure/BotSharp.Abstraction/Settings/ISettingService.cs
GetDetailmethod signature to returnTask instead of
objectConverts the method to be asynchronousTwilioConversationHook.cs
Add await to states Save async callsrc/Plugins/BotSharp.Plugin.Twilio/Hooks/TwilioConversationHook.cs
awaitkeyword tostates.Save()method call61 files