sync and refine

Jicheng Lu · Jicheng Lu · commit 350c479486d0 · 2025-05-15T17:46:36.000-05:00
diff --git a/src/Infrastructure/BotSharp.Abstraction/MCP/Services/IMcpService.cs b/src/Infrastructure/BotSharp.Abstraction/MCP/Services/IMcpService.cs
@@ -2,5 +2,5 @@ namespace BotSharp.Abstraction.MCP.Services;
 
 public interface IMcpService
 {
-    IEnumerable<McpServerOptionModel> GetServerConfigs() => [];
+    Task<IEnumerable<McpServerOptionModel>> GetServerConfigsAsync() => Task.FromResult<IEnumerable<McpServerOptionModel>>([]);
 }
diff --git a/src/Infrastructure/BotSharp.Abstraction/Routing/Executor/IFunctionExecutor.cs b/src/Infrastructure/BotSharp.Abstraction/Routing/Executor/IFunctionExecutor.cs
@@ -1,8 +1,7 @@
-namespace BotSharp.Core.Routing.Executor;
+namespace BotSharp.Abstraction.Routing.Executor;
 
 public interface IFunctionExecutor
 {
     public Task<bool> ExecuteAsync(RoleDialogModel message);
-
     public Task<string> GetIndicatorAsync(RoleDialogModel message);
 }
diff --git a/src/Infrastructure/BotSharp.Core/MCP/BotSharpMCPExtensions.cs b/src/Infrastructure/BotSharp.Core/MCP/BotSharpMCPExtensions.cs
@@ -18,15 +18,11 @@ public static IServiceCollection AddBotSharpMCP(this IServiceCollection services
     {
         var settings = config.GetSection("MCP").Get<McpSettings>();
         services.AddScoped(provider => settings);
+        services.AddScoped<IMcpService, McpService>();
 
         if (settings != null && settings.Enabled && !settings.McpServerConfigs.IsNullOrEmpty())
         {
-            services.AddScoped<IMcpService, McpService>();
-
-            var clientManager = new McpClientManager(settings);
-            services.AddScoped(provider => clientManager);
-
-            // Register hooks
+            services.AddScoped<McpClientManager>();
             services.AddScoped<IAgentHook, McpToolAgentHook>();
         }
         return services;
diff --git a/src/Infrastructure/BotSharp.Core/MCP/Helpers/AiFunctionHelper.cs b/src/Infrastructure/BotSharp.Core/MCP/Helpers/AiFunctionHelper.cs
@@ -1,19 +1,25 @@
-using System.Text.Json;
 using ModelContextProtocol.Client;
 
 namespace BotSharp.Core.MCP.Helpers;
 
 internal static class AiFunctionHelper
 {
-    public static FunctionDef MapToFunctionDef(McpClientTool tool)
+    public static FunctionDef? MapToFunctionDef(McpClientTool tool)
     {
         if (tool == null)
         {
-            throw new ArgumentNullException(nameof(tool));
+            return null;
         }
 
-        var properties = tool.JsonSchema.GetProperty("properties");
-        var required = tool.JsonSchema.GetProperty("required");
+        if (!tool.JsonSchema.TryGetProperty("properties", out var properties))
+        {
+            properties = JsonDocument.Parse("{}").RootElement;
+        }
+
+        if (!tool.JsonSchema.TryGetProperty("required", out var required))
+        {
+            required = JsonDocument.Parse("[]").RootElement;
+        }
 
         var funDef = new FunctionDef
         {
@@ -23,8 +29,8 @@ public static FunctionDef MapToFunctionDef(McpClientTool tool)
             Parameters = new FunctionParametersDef
             {
                 Type = "object",
-                Properties = JsonDocument.Parse(properties.GetRawText()),
-                Required = JsonSerializer.Deserialize<List<string>>(required.GetRawText())
+                Properties = JsonDocument.Parse(properties.GetRawText() ?? "{}"),
+                Required = JsonSerializer.Deserialize<List<string>>(required.GetRawText() ?? "[]") ?? []
             }
         };
 
diff --git a/src/Infrastructure/BotSharp.Core/MCP/Hooks/MCPToolAgentHook.cs b/src/Infrastructure/BotSharp.Core/MCP/Hooks/MCPToolAgentHook.cs
@@ -41,18 +41,26 @@ private async Task<IEnumerable<FunctionDef>> GetMcpContent(Agent agent)
             return functionDefs;
         }
         
-        var mcpClientManager = _services.GetRequiredService<McpClientManager>();
-        var mcps = agent.McpTools.Where(x => !x.Disabled);
+        var mcpClientManager = _services.GetService<McpClientManager>();
+        if (mcpClientManager == null)
+        {
+            return functionDefs;
+        }
+
+        var mcps = agent.McpTools?.Where(x => !x.Disabled) ?? [];
         foreach (var item in mcps)
         {
             var mcpClient =  await mcpClientManager.GetMcpClientAsync(item.ServerId);
-            if (mcpClient != null)
+            if (mcpClient == null) continue;
+
+            var tools = await mcpClient.ListToolsAsync();
+            var toolNames = item.Functions.Select(x => x.Name).ToList();
+            var targetTools = tools.Where(x => toolNames.Contains(x.Name, StringComparer.OrdinalIgnoreCase));
+            foreach (var tool in targetTools)
             {
-                var tools = await mcpClient.ListToolsAsync();
-                var toolnames = item.Functions.Select(x => x.Name).ToList();
-                foreach (var tool in tools.Where(x => toolnames.Contains(x.Name, StringComparer.OrdinalIgnoreCase)))
+                var funDef = AiFunctionHelper.MapToFunctionDef(tool);
+                if (funDef != null)
                 {
-                    var funDef = AiFunctionHelper.MapToFunctionDef(tool);
                     functionDefs.Add(funDef);
                 }
             }
diff --git a/src/Infrastructure/BotSharp.Core/MCP/Managers/McpClientManager.cs b/src/Infrastructure/BotSharp.Core/MCP/Managers/McpClientManager.cs
@@ -6,45 +6,63 @@ namespace BotSharp.Core.MCP.Managers;
 
 public class McpClientManager : IDisposable
 {
-    private readonly McpSettings _mcpSettings;
+    private readonly IServiceProvider _services;
+    private readonly ILogger<McpClientManager> _logger;
 
-    public McpClientManager(McpSettings mcpSettings)
+    public McpClientManager(
+        IServiceProvider services,
+        ILogger<McpClientManager> logger)
     {
-        _mcpSettings = mcpSettings;
+        _services = services;
+        _logger = logger;
     }
 
-    public async Task<IMcpClient> GetMcpClientAsync(string serverId)
+    public async Task<IMcpClient?> GetMcpClientAsync(string serverId)
     {
-        var config = _mcpSettings.McpServerConfigs.Where(x => x.Id == serverId).FirstOrDefault();
-
-        IClientTransport transport;
-        if (config.SseConfig != null)
+        try
         {
-            transport = new SseClientTransport(new SseClientTransportOptions
+            var settings = _services.GetRequiredService<McpSettings>();
+            var config = settings.McpServerConfigs.Where(x => x.Id == serverId).FirstOrDefault();
+            if (config == null)
             {
-                Name = config.Name,
-                Endpoint = new Uri(config.SseConfig.EndPoint),
-                AdditionalHeaders = config.SseConfig.AdditionalHeaders,
-                ConnectionTimeout = config.SseConfig.ConnectionTimeout
-            });
-        }
-        else if (config.StdioConfig != null)
-        {
-            transport = new StdioClientTransport(new StdioClientTransportOptions
+                return null;
+            }
+
+            IClientTransport? transport = null;
+            if (config.SseConfig != null)
+            {
+                transport = new SseClientTransport(new SseClientTransportOptions
+                {
+                    Name = config.Name,
+                    Endpoint = new Uri(config.SseConfig.EndPoint),
+                    AdditionalHeaders = config.SseConfig.AdditionalHeaders,
+                    ConnectionTimeout = config.SseConfig.ConnectionTimeout
+                });
+            }
+            else if (config.StdioConfig != null)
             {
-                Name = config.Name,
-                Command = config.StdioConfig.Command,
-                Arguments = config.StdioConfig.Arguments,
-                EnvironmentVariables = config.StdioConfig.EnvironmentVariables,
-                ShutdownTimeout = config.StdioConfig.ShutdownTimeout
-            });
+                transport = new StdioClientTransport(new StdioClientTransportOptions
+                {
+                    Name = config.Name,
+                    Command = config.StdioConfig.Command,
+                    Arguments = config.StdioConfig.Arguments,
+                    EnvironmentVariables = config.StdioConfig.EnvironmentVariables,
+                    ShutdownTimeout = config.StdioConfig.ShutdownTimeout
+                });
+            }
+
+            if (transport == null)
+            {
+                return null;
+            }
+
+            return await McpClientFactory.CreateAsync(transport, settings.McpClientOptions);
         }
-        else
+        catch (Exception ex)
         {
-            throw new ArgumentNullException("Invalid MCP server configuration!");
+            _logger.LogWarning(ex, $"Error when loading mcp client {serverId}");
+            return null;
         }
-
-        return await McpClientFactory.CreateAsync(transport, _mcpSettings.McpClientOptions);
     }
 
     public void Dispose()
diff --git a/src/Infrastructure/BotSharp.Core/MCP/Services/McpService.cs b/src/Infrastructure/BotSharp.Core/MCP/Services/McpService.cs
@@ -1,6 +1,5 @@
 using BotSharp.Core.MCP.Managers;
 using BotSharp.Core.MCP.Settings;
-using Microsoft.Extensions.Logging;
 using ModelContextProtocol.Client;
 
 namespace BotSharp.Core.MCP.Services;
@@ -9,35 +8,35 @@ public class McpService : IMcpService
 {
     private readonly IServiceProvider _services;
     private readonly ILogger<McpService> _logger;
-    private readonly McpClientManager _mcpClientManager;
 
     public McpService(
         IServiceProvider services,
-        ILogger<McpService> logger, 
-        McpClientManager mcpClient)
+        ILogger<McpService> logger)
     {
         _services = services;
         _logger = logger;
-        _mcpClientManager = mcpClient;
     }
 
-    public IEnumerable<McpServerOptionModel> GetServerConfigs()
+    public async Task<IEnumerable<McpServerOptionModel>> GetServerConfigsAsync()
     {
+        var clientManager = _services.GetService<McpClientManager>();
+        if (clientManager == null) return [];
+
         var options = new List<McpServerOptionModel>();
         var settings = _services.GetRequiredService<McpSettings>();
         var configs = settings?.McpServerConfigs ?? [];
 
         foreach (var config in configs)
         {
-            var tools = _mcpClientManager.GetMcpClientAsync(config.Id)
-                .Result.ListToolsAsync()
-                .Result.Select(x=> x.Name);
+            var client = await clientManager.GetMcpClientAsync(config.Id);
+            if (client == null) continue;
 
+            var tools = await client.ListToolsAsync();
             options.Add(new McpServerOptionModel
             {
                 Id = config.Id,
                 Name = config.Name,
-                Tools = tools
+                Tools = tools.Select(x => x.Name)
             });
         }
 
diff --git a/src/Infrastructure/BotSharp.Core/MCP/Settings/MCPSettings.cs b/src/Infrastructure/BotSharp.Core/MCP/Settings/MCPSettings.cs
@@ -7,5 +7,4 @@ public class McpSettings
     public bool Enabled { get; set; } = true;
     public McpClientOptions McpClientOptions { get; set; }
     public List<McpServerConfigModel> McpServerConfigs { get; set; } = [];
-
 }
diff --git a/src/Infrastructure/BotSharp.Core/Routing/Executor/DummyFunctionExecutor.cs b/src/Infrastructure/BotSharp.Core/Routing/Executor/DummyFunctionExecutor.cs
@@ -1,19 +1,19 @@
+using BotSharp.Abstraction.Routing.Executor;
 using BotSharp.Abstraction.Templating;
 
 namespace BotSharp.Core.Routing.Executor;
 
 public class DummyFunctionExecutor: IFunctionExecutor
 {
-    private FunctionDef functionDef;
     private readonly IServiceProvider _services;
+    private readonly FunctionDef _functionDef;
 
-    public DummyFunctionExecutor(FunctionDef function, IServiceProvider services)
+    public DummyFunctionExecutor(IServiceProvider services, FunctionDef functionDef)
     {
-        functionDef = function;
         _services = services;
+        _functionDef = functionDef;
     }
 
-
     public async Task<bool> ExecuteAsync(RoleDialogModel message)
     {           
         var render = _services.GetRequiredService<ITemplateRender>();
@@ -25,7 +25,7 @@ public async Task<bool> ExecuteAsync(RoleDialogModel message)
             dict[item.Key] = item.Value;
         }
 
-        var text = render.Render(functionDef.Output, dict);
+        var text = render.Render(_functionDef.Output!, dict);
         message.Content = text;
         return true;
     }
diff --git a/src/Infrastructure/BotSharp.Core/Routing/Executor/FunctionCallbackExecutor.cs b/src/Infrastructure/BotSharp.Core/Routing/Executor/FunctionCallbackExecutor.cs
@@ -1,23 +1,24 @@
+using BotSharp.Abstraction.Routing.Executor;
 using BotSharp.Abstraction.Functions;
 
 namespace BotSharp.Core.Routing.Executor;
 
 public  class FunctionCallbackExecutor : IFunctionExecutor
 {
-    IFunctionCallback functionCallback;
+    private readonly IFunctionCallback _functionCallback;
 
     public FunctionCallbackExecutor(IFunctionCallback functionCallback)
     {
-        this.functionCallback = functionCallback;
+        _functionCallback = functionCallback;
     }
 
     public async Task<bool> ExecuteAsync(RoleDialogModel message)
     {
-        return await functionCallback.Execute(message);
+        return await _functionCallback.Execute(message);
     }
 
     public async Task<string> GetIndicatorAsync(RoleDialogModel message)
     {
-       return await functionCallback.GetIndication(message);
+       return await _functionCallback.GetIndication(message);
     }
 }   
diff --git a/src/Infrastructure/BotSharp.Core/Routing/Executor/FunctionExecutorFactory.cs b/src/Infrastructure/BotSharp.Core/Routing/Executor/FunctionExecutorFactory.cs
@@ -1,41 +1,31 @@
 using BotSharp.Abstraction.Functions;
+using BotSharp.Abstraction.Routing.Executor;
 
 namespace BotSharp.Core.Routing.Executor;
 
 internal class FunctionExecutorFactory
 {
-    public static IFunctionExecutor Create(string functionName, Agent agent, IFunctionCallback functioncall, IServiceProvider serviceProvider)
+    public static IFunctionExecutor? Create(IServiceProvider services, string functionName, Agent agent)
     {
-        if(functioncall != null)
+        var functionCall = services.GetServices<IFunctionCallback>().FirstOrDefault(x => x.Name == functionName);
+        if (functionCall != null)
         {
-            return new FunctionCallbackExecutor(functioncall);
+            return new FunctionCallbackExecutor(functionCall);
         }
 
-        var funDef = agent?.Functions?.FirstOrDefault(x => x.Name == functionName);
-        if (funDef != null)
+        var functions = (agent?.Functions ?? []).Concat(agent?.SecondaryFunctions ?? []);
+        var funcDef = functions.FirstOrDefault(x => x.Name == functionName);
+        if (!string.IsNullOrWhiteSpace(funcDef?.Output))
         {
-            if (!string.IsNullOrWhiteSpace(funDef?.Output))
-            {
-                return new DummyFunctionExecutor(funDef,serviceProvider);
-            }                
+            return new DummyFunctionExecutor(services, funcDef);
         }
-        else
+
+        var mcpServerId = agent?.McpTools?.Where(x => x.Functions.Any(y => y.Name == funcDef?.Name))?.FirstOrDefault()?.ServerId;
+        if (!string.IsNullOrWhiteSpace(mcpServerId))
         {
-            funDef = agent?.SecondaryFunctions?.FirstOrDefault(x => x.Name == functionName);
-            if (funDef != null)
-            {
-                if (!string.IsNullOrWhiteSpace(funDef?.Output))
-                {
-                    return new DummyFunctionExecutor(funDef, serviceProvider);
-                }
-                else
-                {
-                    var mcpServerId  = agent?.McpTools?.Where(x => x.Functions.Any(y => y.Name == funDef.Name))
-                        .FirstOrDefault().ServerId;
-                    return new MCPToolExecutor(mcpServerId, functionName, serviceProvider);
-                }
-            }
+            return new McpToolExecutor(services, mcpServerId, functionName);
         }
+        
         return null;
     }
 }
diff --git a/src/Infrastructure/BotSharp.Core/Routing/Executor/MCPToolExecutor.cs b/src/Infrastructure/BotSharp.Core/Routing/Executor/MCPToolExecutor.cs
diff --git a/src/Infrastructure/BotSharp.Core/Routing/RoutingService.InvokeFunction.cs b/src/Infrastructure/BotSharp.Core/Routing/RoutingService.InvokeFunction.cs
diff --git a/src/Infrastructure/BotSharp.OpenAPI/Controllers/McpController.cs b/src/Infrastructure/BotSharp.OpenAPI/Controllers/McpController.cs
diff --git a/src/WebStarter/appsettings.json b/src/WebStarter/appsettings.json

Original file line number	Diff line number	Diff line change
`@@ -2,5 +2,5 @@ namespace BotSharp.Abstraction.MCP.Services;`
`2`	`2`
`3`	`3`	`public interface IMcpService`
`4`	`4`	`{`
`5`		`- IEnumerable<McpServerOptionModel> GetServerConfigs() => [];`
	`5`	`+ Task<IEnumerable<McpServerOptionModel>> GetServerConfigsAsync() => Task.FromResult<IEnumerable<McpServerOptionModel>>([]);`
`6`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,7 @@`
`1`		`-namespace BotSharp.Core.Routing.Executor;`
	`1`	`+namespace BotSharp.Abstraction.Routing.Executor;`
`2`	`2`
`3`	`3`	`public interface IFunctionExecutor`
`4`	`4`	`{`
`5`	`5`	`public Task<bool> ExecuteAsync(RoleDialogModel message);`
`6`		`-`
`7`	`6`	`public Task<string> GetIndicatorAsync(RoleDialogModel message);`
`8`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,15 +18,11 @@ public static IServiceCollection AddBotSharpMCP(this IServiceCollection services`
`18`	`18`	`{`
`19`	`19`	`var settings = config.GetSection("MCP").Get<McpSettings>();`
`20`	`20`	`services.AddScoped(provider => settings);`
	`21`	`+ services.AddScoped<IMcpService, McpService>();`
`21`	`22`
`22`	`23`	`if (settings != null && settings.Enabled && !settings.McpServerConfigs.IsNullOrEmpty())`
`23`	`24`	`{`
`24`		`- services.AddScoped<IMcpService, McpService>();`
`25`		`-`
`26`		`- var clientManager = new McpClientManager(settings);`
`27`		`- services.AddScoped(provider => clientManager);`
`28`		`-`
`29`		`- // Register hooks`
	`25`	`+ services.AddScoped<McpClientManager>();`
`30`	`26`	`services.AddScoped<IAgentHook, McpToolAgentHook>();`
`31`	`27`	`}`
`32`	`28`	`return services;`
Original file line number	Diff line number	Diff line change
`@@ -1,19 +1,25 @@`
`1`		`-using System.Text.Json;`
`2`	`1`	`using ModelContextProtocol.Client;`
`3`	`2`
`4`	`3`	`namespace BotSharp.Core.MCP.Helpers;`
`5`	`4`
`6`	`5`	`internal static class AiFunctionHelper`
`7`	`6`	`{`
`8`		`- public static FunctionDef MapToFunctionDef(McpClientTool tool)`
	`7`	`+ public static FunctionDef? MapToFunctionDef(McpClientTool tool)`
`9`	`8`	`{`
`10`	`9`	`if (tool == null)`
`11`	`10`	`{`
`12`		`- throw new ArgumentNullException(nameof(tool));`
	`11`	`+ return null;`
`13`	`12`	`}`
`14`	`13`
`15`		`- var properties = tool.JsonSchema.GetProperty("properties");`
`16`		`- var required = tool.JsonSchema.GetProperty("required");`
	`14`	`+ if (!tool.JsonSchema.TryGetProperty("properties", out var properties))`
	`15`	`+ {`
	`16`	`+ properties = JsonDocument.Parse("{}").RootElement;`
	`17`	`+ }`
	`18`	`+`
	`19`	`+ if (!tool.JsonSchema.TryGetProperty("required", out var required))`
	`20`	`+ {`
	`21`	`+ required = JsonDocument.Parse("[]").RootElement;`
	`22`	`+ }`
`17`	`23`
`18`	`24`	`var funDef = new FunctionDef`
`19`	`25`	`{`
`@@ -23,8 +29,8 @@ public static FunctionDef MapToFunctionDef(McpClientTool tool)`
`23`	`29`	`Parameters = new FunctionParametersDef`
`24`	`30`	`{`
`25`	`31`	`Type = "object",`
`26`		`- Properties = JsonDocument.Parse(properties.GetRawText()),`
`27`		`- Required = JsonSerializer.Deserialize<List<string>>(required.GetRawText())`
	`32`	`+ Properties = JsonDocument.Parse(properties.GetRawText() ?? "{}"),`
	`33`	`+ Required = JsonSerializer.Deserialize<List<string>>(required.GetRawText() ?? "[]") ?? []`
`28`	`34`	`}`
`29`	`35`	`};`
`30`	`36`
Original file line number	Diff line number	Diff line change
`@@ -41,18 +41,26 @@ private async Task<IEnumerable<FunctionDef>> GetMcpContent(Agent agent)`
`41`	`41`	`return functionDefs;`
`42`	`42`	`}`
`43`	`43`
`44`		`- var mcpClientManager = _services.GetRequiredService<McpClientManager>();`
`45`		`- var mcps = agent.McpTools.Where(x => !x.Disabled);`
	`44`	`+ var mcpClientManager = _services.GetService<McpClientManager>();`
	`45`	`+ if (mcpClientManager == null)`
	`46`	`+ {`
	`47`	`+ return functionDefs;`
	`48`	`+ }`
	`49`	`+`
	`50`	`+ var mcps = agent.McpTools?.Where(x => !x.Disabled) ?? [];`
`46`	`51`	`foreach (var item in mcps)`
`47`	`52`	`{`
`48`	`53`	`var mcpClient = await mcpClientManager.GetMcpClientAsync(item.ServerId);`
`49`		`- if (mcpClient != null)`
	`54`	`+ if (mcpClient == null) continue;`
	`55`	`+`
	`56`	`+ var tools = await mcpClient.ListToolsAsync();`
	`57`	`+ var toolNames = item.Functions.Select(x => x.Name).ToList();`
	`58`	`+ var targetTools = tools.Where(x => toolNames.Contains(x.Name, StringComparer.OrdinalIgnoreCase));`
	`59`	`+ foreach (var tool in targetTools)`
`50`	`60`	`{`
`51`		`- var tools = await mcpClient.ListToolsAsync();`
`52`		`- var toolnames = item.Functions.Select(x => x.Name).ToList();`
`53`		`- foreach (var tool in tools.Where(x => toolnames.Contains(x.Name, StringComparer.OrdinalIgnoreCase)))`
	`61`	`+ var funDef = AiFunctionHelper.MapToFunctionDef(tool);`
	`62`	`+ if (funDef != null)`
`54`	`63`	`{`
`55`		`- var funDef = AiFunctionHelper.MapToFunctionDef(tool);`
`56`	`64`	`functionDefs.Add(funDef);`
`57`	`65`	`}`
`58`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,5 +7,4 @@ public class McpSettings`
`7`	`7`	`public bool Enabled { get; set; } = true;`
`8`	`8`	`public McpClientOptions McpClientOptions { get; set; }`
`9`	`9`	`public List<McpServerConfigModel> McpServerConfigs { get; set; } = [];`
`10`		`-`
`11`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,19 +1,19 @@`
	`1`	`+using BotSharp.Abstraction.Routing.Executor;`
`1`	`2`	`using BotSharp.Abstraction.Templating;`
`2`	`3`
`3`	`4`	`namespace BotSharp.Core.Routing.Executor;`
`4`	`5`
`5`	`6`	`public class DummyFunctionExecutor: IFunctionExecutor`
`6`	`7`	`{`
`7`		`- private FunctionDef functionDef;`
`8`	`8`	`private readonly IServiceProvider _services;`
	`9`	`+ private readonly FunctionDef _functionDef;`
`9`	`10`
`10`		`- public DummyFunctionExecutor(FunctionDef function, IServiceProvider services)`
	`11`	`+ public DummyFunctionExecutor(IServiceProvider services, FunctionDef functionDef)`
`11`	`12`	`{`
`12`		`- functionDef = function;`
`13`	`13`	`_services = services;`
	`14`	`+ _functionDef = functionDef;`
`14`	`15`	`}`
`15`	`16`
`16`		`-`
`17`	`17`	`public async Task<bool> ExecuteAsync(RoleDialogModel message)`
`18`	`18`	`{`
`19`	`19`	`var render = _services.GetRequiredService<ITemplateRender>();`
`@@ -25,7 +25,7 @@ public async Task<bool> ExecuteAsync(RoleDialogModel message)`
`25`	`25`	`dict[item.Key] = item.Value;`
`26`	`26`	`}`
`27`	`27`
`28`		`- var text = render.Render(functionDef.Output, dict);`
	`28`	`+ var text = render.Render(_functionDef.Output!, dict);`
`29`	`29`	`message.Content = text;`
`30`	`30`	`return true;`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,23 +1,24 @@`
	`1`	`+using BotSharp.Abstraction.Routing.Executor;`
`1`	`2`	`using BotSharp.Abstraction.Functions;`
`2`	`3`
`3`	`4`	`namespace BotSharp.Core.Routing.Executor;`
`4`	`5`
`5`	`6`	`public class FunctionCallbackExecutor : IFunctionExecutor`
`6`	`7`	`{`
`7`		`- IFunctionCallback functionCallback;`
	`8`	`+ private readonly IFunctionCallback _functionCallback;`
`8`	`9`
`9`	`10`	`public FunctionCallbackExecutor(IFunctionCallback functionCallback)`
`10`	`11`	`{`
`11`		`- this.functionCallback = functionCallback;`
	`12`	`+ _functionCallback = functionCallback;`
`12`	`13`	`}`
`13`	`14`
`14`	`15`	`public async Task<bool> ExecuteAsync(RoleDialogModel message)`
`15`	`16`	`{`
`16`		`- return await functionCallback.Execute(message);`
	`17`	`+ return await _functionCallback.Execute(message);`
`17`	`18`	`}`
`18`	`19`
`19`	`20`	`public async Task<string> GetIndicatorAsync(RoleDialogModel message)`
`20`	`21`	`{`
`21`		`- return await functionCallback.GetIndication(message);`
	`22`	`+ return await _functionCallback.GetIndication(message);`
`22`	`23`	`}`
`23`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,41 +1,31 @@`
`1`	`1`	`using BotSharp.Abstraction.Functions;`
	`2`	`+using BotSharp.Abstraction.Routing.Executor;`
`2`	`3`
`3`	`4`	`namespace BotSharp.Core.Routing.Executor;`
`4`	`5`
`5`	`6`	`internal class FunctionExecutorFactory`
`6`	`7`	`{`
`7`		`- public static IFunctionExecutor Create(string functionName, Agent agent, IFunctionCallback functioncall, IServiceProvider serviceProvider)`
	`8`	`+ public static IFunctionExecutor? Create(IServiceProvider services, string functionName, Agent agent)`
`8`	`9`	`{`
`9`		`- if(functioncall != null)`
	`10`	`+ var functionCall = services.GetServices<IFunctionCallback>().FirstOrDefault(x => x.Name == functionName);`
	`11`	`+ if (functionCall != null)`
`10`	`12`	`{`
`11`		`- return new FunctionCallbackExecutor(functioncall);`
	`13`	`+ return new FunctionCallbackExecutor(functionCall);`
`12`	`14`	`}`
`13`	`15`
`14`		`- var funDef = agent?.Functions?.FirstOrDefault(x => x.Name == functionName);`
`15`		`- if (funDef != null)`
	`16`	`+ var functions = (agent?.Functions ?? []).Concat(agent?.SecondaryFunctions ?? []);`
	`17`	`+ var funcDef = functions.FirstOrDefault(x => x.Name == functionName);`
	`18`	`+ if (!string.IsNullOrWhiteSpace(funcDef?.Output))`
`16`	`19`	`{`
`17`		`- if (!string.IsNullOrWhiteSpace(funDef?.Output))`
`18`		`- {`
`19`		`- return new DummyFunctionExecutor(funDef,serviceProvider);`
`20`		`- }`
	`20`	`+ return new DummyFunctionExecutor(services, funcDef);`
`21`	`21`	`}`
`22`		`- else`
	`22`	`+`
	`23`	`+ var mcpServerId = agent?.McpTools?.Where(x => x.Functions.Any(y => y.Name == funcDef?.Name))?.FirstOrDefault()?.ServerId;`
	`24`	`+ if (!string.IsNullOrWhiteSpace(mcpServerId))`
`23`	`25`	`{`
`24`		`- funDef = agent?.SecondaryFunctions?.FirstOrDefault(x => x.Name == functionName);`
`25`		`- if (funDef != null)`
`26`		`- {`
`27`		`- if (!string.IsNullOrWhiteSpace(funDef?.Output))`
`28`		`- {`
`29`		`- return new DummyFunctionExecutor(funDef, serviceProvider);`
`30`		`- }`
`31`		`- else`
`32`		`- {`
`33`		`- var mcpServerId = agent?.McpTools?.Where(x => x.Functions.Any(y => y.Name == funDef.Name))`
`34`		`- .FirstOrDefault().ServerId;`
`35`		`- return new MCPToolExecutor(mcpServerId, functionName, serviceProvider);`
`36`		`- }`
`37`		`- }`
	`26`	`+ return new McpToolExecutor(services, mcpServerId, functionName);`
`38`	`27`	`}`
	`28`	`+`
`39`	`29`	`return null;`
`40`	`30`	`}`
`41`	`31`	`}`