wip tests

src/Utility/ChatTools.cs

@@ -251,7 +251,7 @@ internal string CallLocal(ChatToolCall call)
                 arguments.Add(argument.Value.ValueKind switch
                 {
                     JsonValueKind.String => argument.Value.GetString()!,
-                    JsonValueKind.Number => argument.Value.GetDouble(),
+                    JsonValueKind.Number => argument.Value.GetInt32(),
                     JsonValueKind.True => true,
                     JsonValueKind.False => false,
                     _ => throw new NotImplementedException()

src/Utility/ToolsUtility.cs

@@ -36,6 +36,7 @@ internal static ReadOnlySpan<byte> ClrToJsonTypeUtf8(Type clrType) =>
         clrType switch
         {
             Type t when t == typeof(double) => "number"u8,
+            Type t when t == typeof(int) => "number"u8,
             Type t when t == typeof(string) => "string"u8,
             Type t when t == typeof(bool) => "bool"u8,
             _ => throw new NotImplementedException()
@@ -45,6 +46,7 @@ internal static string ClrToJsonTypeUtf16(Type clrType) =>
         clrType switch
         {
             Type t when t == typeof(double) => "number",
+            Type t when t == typeof(int) => "number",
             Type t when t == typeof(string) => "string",
             Type t when t == typeof(bool) => "bool",
             _ => throw new NotImplementedException()

tests/Utility/ChatToolsTests.cs

@@ -0,0 +1,131 @@
+using Moq;
+using NUnit.Framework;
+using OpenAI.Chat;
+using OpenAI.Embeddings;
+using System;
+using System.Collections.Generic;
+using System.ClientModel;
+using System.ClientModel.Primitives;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace OpenAI.Tests.Utility;
+
+[TestFixture]
+[Category("Utility")]
+public class ChatToolsTests
+{
+    private class TestTools
+    {
+        public static string Echo(string message) => message;
+        public static int Add(int a, int b) => a + b;
+    }
+
+    private Mock<EmbeddingClient> mockEmbeddingClient;
+
+    [SetUp]
+    public void Setup()
+    {
+        mockEmbeddingClient = new Mock<EmbeddingClient>("text-embedding-ada-002", new ApiKeyCredential("test-key"));
+    }
+
+    [Test]
+    public void CanAddLocalTools()
+    {
+        var tools = new ChatTools();
+        tools.AddLocalTools(typeof(TestTools));
+
+        Assert.That(tools.Tools, Has.Count.EqualTo(2));
+        Assert.That(tools.Tools.Any(t => t.FunctionName == "Echo"));
+        Assert.That(tools.Tools.Any(t => t.FunctionName == "Add"));
+    }
+
+    [Test]
+    public async Task CanCallToolsAsync()
+    {
+        var tools = new ChatTools();
+        tools.AddLocalTools(typeof(TestTools));
+
+        var toolCalls = new[]
+        {
+            ChatToolCall.CreateFunctionToolCall("call1", "Echo", BinaryData.FromString(@"{""message"": ""Hello""}")),
+            ChatToolCall.CreateFunctionToolCall("call2", "Add", BinaryData.FromString(@"{""a"": 2, ""b"": 3}"))
+        };
+
+        var results = await tools.CallAsync(toolCalls);
+        var resultsList = results.ToList();
+
+        Assert.That(resultsList, Has.Count.EqualTo(2));
+        Assert.That(resultsList[0].ToolCallId, Is.EqualTo("call1"));
+        Assert.That(resultsList[0].Content[0].Text, Is.EqualTo("Hello"));
+        Assert.That(resultsList[1].ToolCallId, Is.EqualTo("call2"));
+        Assert.That(resultsList[1].Content[0].Text, Is.EqualTo("5"));
+    }
+
+    [Test]
+    public void CreatesCompletionOptionsWithTools()
+    {
+        var tools = new ChatTools();
+        tools.AddLocalTools(typeof(TestTools));
+
+        var options = tools.CreateCompletionOptions();
+
+        Assert.That(options.Tools, Has.Count.EqualTo(2));
+        Assert.That(options.Tools.Any(t => t.FunctionName == "Echo"));
+        Assert.That(options.Tools.Any(t => t.FunctionName == "Add"));
+    }
+
+    [Test]
+    public async Task CanFilterToolsByRelevance()
+    {
+        // Setup mock embedding client to return a mock response
+        var embedding = OpenAIEmbeddingsModelFactory.OpenAIEmbedding(vector: new[] { 0.5f, 0.5f });
+        var embeddingCollection = OpenAIEmbeddingsModelFactory.OpenAIEmbeddingCollection(
+            items: new[] { embedding },
+            model: "text-embedding-ada-002",
+            usage: OpenAIEmbeddingsModelFactory.EmbeddingTokenUsage(10, 10));
+        var mockResponse = new MockPipelineResponse(200);
+
+        mockEmbeddingClient
+            .Setup(c => c.GenerateEmbeddingAsync(
+                It.IsAny<string>(),
+                It.IsAny<EmbeddingGenerationOptions>(),
+                It.IsAny<CancellationToken>()))
+            .ReturnsAsync(ClientResult.FromValue(embedding, mockResponse));
+
+        var tools = new ChatTools(mockEmbeddingClient.Object);
+        tools.AddLocalTools(typeof(TestTools));
+
+        var options = await Task.Run(() => tools.CreateCompletionOptions("Need to add two numbers", 1, 0.5f));
+
+        Assert.That(options.Tools, Has.Count.LessThanOrEqualTo(1));
+    }
+
+    [Test]
+    public void ImplicitConversionToCompletionOptions()
+    {
+        var tools = new ChatTools();
+        tools.AddLocalTools(typeof(TestTools));
+
+        ChatCompletionOptions options = tools;
+
+        Assert.That(options.Tools, Has.Count.EqualTo(2));
+        Assert.That(options.Tools.Any(t => t.FunctionName == "Echo"));
+        Assert.That(options.Tools.Any(t => t.FunctionName == "Add"));
+    }
+
+    [Test]
+    public void ThrowsWhenCallingNonExistentTool()
+    {
+        var tools = new ChatTools();
+        var toolCalls = new[]
+        {
+            ChatToolCall.CreateFunctionToolCall("call1", "NonExistentTool", BinaryData.FromString("{}"))
+        };
+
+        Assert.ThrowsAsync<InvalidOperationException>(() => tools.CallAsync(toolCalls));
+    }
+}

tests/Utility/ResponseToolsTests.cs

@@ -0,0 +1,126 @@
+using Moq;
+using NUnit.Framework;
+using OpenAI.Embeddings;
+using OpenAI.Responses;
+using System;
+using System.ClientModel;
+using System.ClientModel.Primitives;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace OpenAI.Tests.Utility;
+
+[TestFixture]
+[Category("Utility")]
+public class ResponseToolsTests
+{
+    private class TestTools
+    {
+        public static string Echo(string message) => message;
+        public static int Add(int a, int b) => a + b;
+    }
+
+    private Mock<EmbeddingClient> mockEmbeddingClient;
+
+    [SetUp]
+    public void Setup()
+    {
+        mockEmbeddingClient = new Mock<EmbeddingClient>("text-embedding-ada-002", new ApiKeyCredential("test-key"));
+    }
+
+    [Test]
+    public void CanAddLocalTools()
+    {
+        var tools = new ResponseTools();
+        tools.AddLocalTools(typeof(TestTools));
+
+        Assert.That(tools.Tools, Has.Count.EqualTo(2));
+        Assert.That(tools.Tools.Any(t => ((string)t.GetType().GetProperty("Name").GetValue(t)).Contains("Echo")));
+        Assert.That(tools.Tools.Any(t => ((string)t.GetType().GetProperty("Name").GetValue(t)).Contains("Add")));
+    }
+
+    [Test]
+    public async Task CanCallToolAsync()
+    {
+        var tools = new ResponseTools();
+        tools.AddLocalTools(typeof(TestTools));
+
+        var toolCall = new FunctionCallResponseItem("call1", "Echo", BinaryData.FromString(@"{""message"": ""Hello""}"));
+        var result = await tools.CallAsync(toolCall);
+
+        Assert.That(result.CallId, Is.EqualTo("call1"));
+        Assert.That(result.ToString(), Is.EqualTo("Hello"));
+
+        var addCall = new FunctionCallResponseItem("call2", "Add", BinaryData.FromString(@"{""a"": 2, ""b"": 3}"));
+        result = await tools.CallAsync(addCall);
+
+        Assert.That(result.CallId, Is.EqualTo("call2"));
+        Assert.That(result.ToString(), Is.EqualTo("5"));
+    }
+
+    [Test]
+    public void CreatesResponseOptionsWithTools()
+    {
+        var tools = new ResponseTools();
+        tools.AddLocalTools(typeof(TestTools));
+
+        var options = tools.CreateResponseOptions();
+
+        Assert.That(options.Tools, Has.Count.EqualTo(2));
+        Assert.That(options.Tools.Any(t => t.ToString().Contains("Echo")));
+        Assert.That(options.Tools.Any(t => t.ToString().Contains("Add")));
+    }
+
+    [Test]
+    public async Task CanFilterToolsByRelevance()
+    {
+        // Setup mock embedding client to return a mock response
+        var embedding = OpenAIEmbeddingsModelFactory.OpenAIEmbedding(vector: new[] { 0.5f, 0.5f });
+        var embeddingCollection = OpenAIEmbeddingsModelFactory.OpenAIEmbeddingCollection(
+            items: new[] { embedding },
+            model: "text-embedding-ada-002",
+            usage: OpenAIEmbeddingsModelFactory.EmbeddingTokenUsage(10, 10));
+        var mockResponse = new MockPipelineResponse(200);
+
+        mockEmbeddingClient
+            .Setup(c => c.GenerateEmbeddingsAsync(
+                It.IsAny<BinaryContent>(),
+                It.IsAny<RequestOptions>()))
+            .ReturnsAsync(ClientResult.FromValue(embeddingCollection, mockResponse));
+
+        var tools = new ResponseTools(mockEmbeddingClient.Object);
+        tools.AddLocalTools(typeof(TestTools));
+
+        var options = await Task.Run(() => tools.CreateResponseOptions("Need to add two numbers", 1, 0.5f));
+
+        Assert.That(options.Tools, Has.Count.LessThanOrEqualTo(1));
+        mockEmbeddingClient.Verify(
+            c => c.GenerateEmbeddingsAsync(
+                It.IsAny<BinaryContent>(),
+                It.IsAny<RequestOptions>()),
+            Times.Once);
+    }
+
+    [Test]
+    public void ImplicitConversionToResponseOptions()
+    {
+        var tools = new ResponseTools();
+        tools.AddLocalTools(typeof(TestTools));
+
+        ResponseCreationOptions options = tools;
+
+        Assert.That(options.Tools, Has.Count.EqualTo(2));
+        Assert.That(options.Tools.Any(t => t.ToString().Contains("Echo")));
+        Assert.That(options.Tools.Any(t => t.ToString().Contains("Add")));
+    }
+
+    [Test]
+    public async Task ReturnsErrorForNonExistentTool()
+    {
+        var tools = new ResponseTools();
+        var toolCall = new FunctionCallResponseItem("call1", "NonExistentTool", BinaryData.FromString("{}"));
+
+        var result = await tools.CallAsync(toolCall);
+        Assert.That(result.ToString(), Does.StartWith("I don't have a tool called"));
+    }
+}