Add micro agent service demo to ExampleTool

Author: benbp

tools/azsdk-cli/Azure.Sdk.Tools.Cli.Tests/Microagents/MicroagentHostServiceTests.cs

@@ -3,6 +3,8 @@
 using Azure.AI.OpenAI;
 using Azure.Sdk.Tools.Cli.Microagents;
 using Azure.Sdk.Tools.Cli.Microagents.Tools;
+using Azure.Sdk.Tools.Cli.Helpers;
+using NUnit.Framework;
 using Moq;
 using OpenAI.Chat;
 
@@ -23,7 +25,8 @@ public void Setup()
         chatClientMock = new Mock<ChatClient>();
         openAIClientMock.Setup(client => client.GetChatClient(It.IsAny<string>()))
             .Returns(chatClientMock.Object);
-        microagentHostService = new MicroagentHostService(openAIClientMock.Object, loggerMock.Object);
+        var tokenUsageHelper = new TokenUsageHelper(Mock.Of<Azure.Sdk.Tools.Cli.Helpers.IOutputHelper>());
+        microagentHostService = new MicroagentHostService(openAIClientMock.Object, loggerMock.Object, tokenUsageHelper);
     }
 
     [Test]

tools/azsdk-cli/Azure.Sdk.Tools.Cli.Tests/Tools/ExampleToolTests.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 using Moq;
+using NUnit.Framework;
 using NUnit.Framework.Internal;
 using Azure.Core;
 using Azure.Sdk.Tools.Cli.Helpers;
@@ -22,6 +23,7 @@ internal class ExampleToolTests
     private MockGitHubService? mockGitHubService;
     private Mock<IProcessHelper>? mockProcessHelper;
     private Mock<IPowershellHelper>? mockPowershellHelper;
+    private Mock<Azure.Sdk.Tools.Cli.Microagents.IMicroagentHostService>? mockMicroagentHostService;
 
     [SetUp]
     public void Setup()
@@ -33,6 +35,7 @@ public void Setup()
         mockGitHubService = new MockGitHubService();
         mockProcessHelper = new Mock<IProcessHelper>();
         mockPowershellHelper = new Mock<IPowershellHelper>();
+        mockMicroagentHostService = new Mock<Azure.Sdk.Tools.Cli.Microagents.IMicroagentHostService>();
 
         // Set up Azure service mock to return a mock credential
         var mockCredential = new Mock<TokenCredential>();
@@ -59,6 +62,7 @@ public void Setup()
             mockProcessHelper.Object,
             mockPowershellHelper.Object,
             tokenUsageHelper: new TokenUsageHelper(mockOutput.Object),
+            mockMicroagentHostService.Object,
 #pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
             null
 #pragma warning restore CS8625 // Cannot convert null literal to non-nullable reference type.
@@ -154,7 +158,7 @@ public void GetCommand_ReturnsCommandWithCorrectSubCommands()
 
         Assert.That(command.Name, Is.EqualTo("demo"));
         Assert.That(command.Description, Does.Contain("Comprehensive demonstration"));
-        Assert.That(command.Subcommands.Count, Is.EqualTo(7));
+        Assert.That(command.Subcommands.Count, Is.EqualTo(8));
 
         var subCommandNames = command.Subcommands.Select(sc => sc.Name).ToList();
         Assert.That(subCommandNames, Does.Contain("azure"));
@@ -164,6 +168,7 @@ public void GetCommand_ReturnsCommandWithCorrectSubCommands()
         Assert.That(subCommandNames, Does.Contain("error"));
         Assert.That(subCommandNames, Does.Contain("process"));
         Assert.That(subCommandNames, Does.Contain("powershell"));
+        Assert.That(subCommandNames, Does.Contain("microagent"));
     }
 
     [Test]
@@ -237,7 +242,6 @@ public async Task DemonstratePowershellExecution_Success()
     {
         mockPowershellHelper!.Setup(p => p.Run(It.IsAny<PowershellOptions>(), It.IsAny<CancellationToken>()))
             .ReturnsAsync(new ProcessResult { ExitCode = 0, });
-
         var result = await tool.DemonstratePowershellExecution("foobar");
 
         Assert.That(result.ResponseError, Is.Null);
@@ -246,4 +250,16 @@ public async Task DemonstratePowershellExecution_Success()
         Assert.That(result.Result, Is.Empty);
         Assert.That(result.Details?["exit_code"], Is.EqualTo("0"));
     }
+
+    [Test]
+    public async Task DemonstrateMicroagentFibonacci_Success()
+    {
+        mockMicroagentHostService!.Setup(m => m.RunAgentToCompletion(It.IsAny<Azure.Sdk.Tools.Cli.Microagents.Microagent<int>>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(13);
+
+        var response = await tool.DemonstrateMicroagentFibonacci(7);
+
+        Assert.That(response.ResponseError, Is.Null);
+        Assert.That(response.Result as string, Does.Contain("Fibonacci(7) = 13"));
+    }
 }

tools/azsdk-cli/Azure.Sdk.Tools.Cli/Microagents/MicroagentHostService.cs

@@ -61,7 +61,10 @@ public async Task<TResult> RunAgentToCompletion<TResult>(Microagent<TResult> age
             // Request the chat completion
             logger.LogDebug("Sending conversation history with {MessageCount} messages to model '{Model}'", conversationHistory.Count, agentDefinition.Model);
             var response = await chatClient.CompleteChatAsync(conversationHistory, chatCompletionOptions, ct);
-            tokenUsageHelper.Add(agentDefinition.Model, response.Value.Usage.InputTokenCount, response.Value.Usage.OutputTokenCount);
+            if (null != response.Value.Usage)
+            {
+                tokenUsageHelper.Add(agentDefinition.Model, response.Value.Usage.InputTokenCount, response.Value.Usage.OutputTokenCount);
+            }
 
             var toolCall = response.Value.ToolCalls.Single();
             logger.LogInformation("Model called tool '{ToolName}'", toolCall.FunctionName);
@@ -106,7 +109,7 @@ public async Task<TResult> RunAgentToCompletion<TResult>(Microagent<TResult> age
             conversationHistory.Add(ChatMessage.CreateToolMessage(toolCall.Id, toolResult));
         }
 
-        throw new Exception("Agent did not return a result within the maximum number of iterations");
+        throw new Exception($"Agent did not return a result within the maximum number of {agentDefinition.MaxToolCalls} iterations");
     }
 
     /// <summary>

tools/azsdk-cli/Azure.Sdk.Tools.Cli/Program.cs

@@ -66,7 +66,7 @@ public static WebApplicationBuilder CreateAppBuilder(string[] args)
         // Skip azure client logging noise
         builder.Logging.AddFilter((category, level) =>
         {
-            if (null == category) { return level >= logLevel; }
+            if (debug || null == category) { return level >= logLevel; }
             var isAzureClient = category.StartsWith("Azure.", StringComparison.Ordinal);
             var isToolsClient = category.StartsWith("Azure.Sdk.Tools.", StringComparison.Ordinal);
             if (isAzureClient && !isToolsClient) { return level >= LogLevel.Error; }

tools/azsdk-cli/Azure.Sdk.Tools.Cli/Tools/Example/ExampleTool.cs

@@ -11,6 +11,7 @@
 using Azure.Sdk.Tools.Cli.Helpers;
 using ModelContextProtocol.Server;
 using OpenAI.Chat;
+using Azure.Sdk.Tools.Cli.Microagents;
 
 namespace Azure.Sdk.Tools.Cli.Tools.Example;
 
@@ -26,6 +27,7 @@ public class ExampleTool : MCPTool
     private const string ErrorSubCommand = "error";
     private const string ProcessSubCommand = "process";
     private const string PowershellSubCommand = "powershell";
+    private const string MicroagentSubCommand = "microagent";
 
     // Dependencies injected via constructor
     private readonly ILogger<ExampleTool> logger;
@@ -37,6 +39,7 @@ public class ExampleTool : MCPTool
     private readonly IProcessHelper processHelper;
     private readonly IPowershellHelper powershellHelper;
     private readonly TokenUsageHelper tokenUsageHelper;
+    private readonly IMicroagentHostService microagentHostService;
 
     // CLI Options and Arguments
     private readonly Argument<string> aiInputArg = new(
@@ -68,6 +71,11 @@ public class ExampleTool : MCPTool
         description: "Message to pass to the PowerShell script via parameter")
     { Arity = ArgumentArity.ExactlyOne };
 
+    private readonly Option<int> fibonacciIndexOption = new(
+        name: "--fibonacci",
+        description: "Index (0-based) of Fibonacci number to compute using micro-agent")
+    { IsRequired = true };
+
     private readonly Option<string> tenantOption = new(["--tenant", "-t"], "Tenant ID");
     private readonly Option<string> languageOption = new(["--language", "-l"], "Programming language of the repository");
     private readonly Option<string> promptOption = new(["--prompt", "-p"], "AI prompt text");
@@ -83,6 +91,7 @@ public ExampleTool(
         IProcessHelper processHelper,
         IPowershellHelper powershellHelper,
         TokenUsageHelper tokenUsageHelper,
+        IMicroagentHostService microagentHostService,
         AzureOpenAIClient openAIClient
     ) : base()
     {
@@ -95,6 +104,7 @@ AzureOpenAIClient openAIClient
         this.processHelper = processHelper;
         this.powershellHelper = powershellHelper;
         this.tokenUsageHelper = tokenUsageHelper;
+        this.microagentHostService = microagentHostService;
 
         // Set command hierarchy - results in: azsdk example
         CommandHierarchy = [
@@ -142,13 +152,19 @@ public override Command GetCommand()
         powershellCmd.AddArgument(powershellMessageArg);
         powershellCmd.SetHandler(async ctx => { await HandleCommand(ctx, ctx.GetCancellationToken()); });
 
+        // Microagent Fibonacci demo sub-command
+        var microagentCmd = new Command(MicroagentSubCommand, "Demonstrate micro-agent looping tool calls to compute Fibonacci");
+        microagentCmd.AddOption(fibonacciIndexOption);
+        microagentCmd.SetHandler(async ctx => { await HandleCommand(ctx, ctx.GetCancellationToken()); });
+
         parentCommand.Add(azureCmd);
         parentCommand.Add(devopsCmd);
         parentCommand.Add(githubCmd);
         parentCommand.Add(aiCmd);
         parentCommand.Add(errorCmd);
         parentCommand.Add(processCmd);
         parentCommand.Add(powershellCmd);
+        parentCommand.Add(microagentCmd);
 
         return parentCommand;
     }
@@ -166,6 +182,7 @@ public override async Task HandleCommand(InvocationContext ctx, CancellationToke
             ErrorSubCommand => await DemonstrateErrorHandling(ctx.ParseResult.GetValueForArgument(errorInputArg), ctx.ParseResult.GetValueForOption(forceFailureOption), ct),
             ProcessSubCommand => await DemonstrateProcessExecution(ctx.ParseResult.GetValueForArgument(processSleepArg), ct),
             PowershellSubCommand => await DemonstratePowershellExecution(ctx.ParseResult.GetValueForArgument(powershellMessageArg), ct),
+            MicroagentSubCommand => await DemonstrateMicroagentFibonacci(ctx.ParseResult.GetValueForOption(fibonacciIndexOption), ct),
             _ => new ExampleServiceResponse { ResponseError = $"Unknown command: {commandName}" }
         };
 
@@ -486,5 +503,64 @@ public async Task<ExampleServiceResponse> DemonstratePowershellExecution(string
             }
         }
     }
+
+    public record Fibonacci
+    {
+        public int Index { get; set; }
+        public int Previous { get; set; }
+        public int Current { get; set; }
+    }
+
+    [McpServerTool(Name = "azsdk_example_microagent_fibonacci"), Description("Demonstrates micro-agent computing Nth Fibonacci number via iterative tool calls")]
+    public async Task<DefaultCommandResponse> DemonstrateMicroagentFibonacci(int n, CancellationToken ct = default)
+    {
+        try
+        {
+            if (n < 2)
+            {
+                SetFailure();
+                return new DefaultCommandResponse { ResponseError = "--fibonacci must be >= 2 to exercise the micro-agent (trivial cases are disallowed)" };
+            }
+
+            var advanceTool = AgentTool<Fibonacci, Fibonacci>.FromFunc(
+                name: "advance_state",
+                description: "Advances state by one step",
+                invokeHandler: (input, ct) =>
+                {
+                    return Task.FromResult(new Fibonacci
+                    {
+                        Index = input.Index + 1,
+                        Previous = input.Current,
+                        Current = input.Previous + input.Current
+                    });
+                });
+
+            // Avoid mentioning 'fibonacci' in the instructions so the LLM doesn't try to calculate it directly
+            var instructions = $"""
+                Call advance_state repeatedly until the returned index == {n}.
+                Return the '{nameof(Fibonacci.Current)}' value when index == {n}.
+                Initial state is {nameof(Fibonacci.Index)}=1, {nameof(Fibonacci.Previous)}=0, {nameof(Fibonacci.Current)}=1.
+            """;
+
+            var agent = new Microagent<int>
+            {
+                Instructions = instructions,
+                MaxToolCalls = 7,
+                Tools = [advanceTool],
+            };
+
+            var resultValue = await microagentHostService.RunAgentToCompletion(agent, ct);
+
+            tokenUsageHelper.LogCost();
+            return new DefaultCommandResponse { Result = $"Fibonacci({n}) = {resultValue}" };
+        }
+        catch (Exception ex)
+        {
+            tokenUsageHelper.LogCost();
+            logger.LogError(ex, "Error demonstrating micro-agent Fibonacci for n={n}", n);
+            SetFailure();
+            return new DefaultCommandResponse { ResponseError = $"Failed to compute Fibonacci({n}): {ex.Message}" };
+        }
+    }
 }
 #endif