test: add corner-case tests for AudioContent, tool version, and output schema

Cover gaps found during cross-implementation testing:
- AudioContent serialization and handler round-trip (content.cpp, server_handler.cpp)
- Tool version metadata appears in tools/list wire format (handler.cpp)
- Output schema null vs empty-object distinction (handler.cpp)
- Client-side AudioContent parsing via parse_content_block (test_audio_content.cpp)
- Add AudioContent to client ContentBlock variant (types.hpp)

Author: 0xeb

CMakeLists.txt

@@ -434,6 +434,10 @@ if(FASTMCPP_BUILD_TESTS)
   target_link_libraries(fastmcpp_client_sampling_handlers PRIVATE fastmcpp_core)
   add_test(NAME fastmcpp_client_sampling_handlers COMMAND fastmcpp_client_sampling_handlers)
 
+  add_executable(fastmcpp_client_audio_content tests/client/test_audio_content.cpp)
+  target_link_libraries(fastmcpp_client_audio_content PRIVATE fastmcpp_core)
+  add_test(NAME fastmcpp_client_audio_content COMMAND fastmcpp_client_audio_content)
+
   add_executable(fastmcpp_server_middleware tests/server/middleware.cpp)
   target_link_libraries(fastmcpp_server_middleware PRIVATE fastmcpp_core)
   add_test(NAME fastmcpp_server_middleware COMMAND fastmcpp_server_middleware)

include/fastmcpp/client/types.hpp

@@ -34,6 +34,14 @@ struct ImageContent
     std::string mimeType; ///< e.g., "image/png"
 };
 
+/// Audio content block
+struct AudioContent
+{
+    std::string type{"audio"};
+    std::string data;     ///< Base64-encoded audio bytes
+    std::string mimeType; ///< e.g., "audio/wav", "audio/mpeg"
+};
+
 /// Embedded resource content
 struct EmbeddedResourceContent
 {
@@ -45,7 +53,7 @@ struct EmbeddedResourceContent
 };
 
 /// Content block variant (matches mcp.types.ContentBlock)
-using ContentBlock = std::variant<TextContent, ImageContent, EmbeddedResourceContent>;
+using ContentBlock = std::variant<TextContent, ImageContent, AudioContent, EmbeddedResourceContent>;
 
 // ============================================================================
 // Tool Types
@@ -331,6 +339,18 @@ inline void from_json(const fastmcpp::Json& j, ImageContent& c)
     c.mimeType = j.at("mimeType").get<std::string>();
 }
 
+inline void to_json(fastmcpp::Json& j, const AudioContent& c)
+{
+    j = fastmcpp::Json{{"type", c.type}, {"data", c.data}, {"mimeType", c.mimeType}};
+}
+
+inline void from_json(const fastmcpp::Json& j, AudioContent& c)
+{
+    c.type = j.value("type", "audio");
+    c.data = j.at("data").get<std::string>();
+    c.mimeType = j.at("mimeType").get<std::string>();
+}
+
 inline void to_json(fastmcpp::Json& j, const ToolInfo& t)
 {
     j = fastmcpp::Json{{"name", t.name}, {"inputSchema", t.inputSchema}};
@@ -551,6 +571,10 @@ inline ContentBlock parse_content_block(const fastmcpp::Json& j)
     {
         return j.get<ImageContent>();
     }
+    else if (type == "audio")
+    {
+        return j.get<AudioContent>();
+    }
     else if (type == "resource")
     {
         EmbeddedResourceContent c;

tests/client/test_audio_content.cpp

@@ -0,0 +1,28 @@
+#include "fastmcpp/client/types.hpp"
+
+#include <cassert>
+
+int main()
+{
+    using namespace fastmcpp;
+
+    // Parse audio content block
+    Json audio_json = {{"type", "audio"}, {"data", "aGVsbG8="}, {"mimeType", "audio/wav"}};
+    auto block = client::parse_content_block(audio_json);
+    auto* ac = std::get_if<client::AudioContent>(&block);
+    assert(ac != nullptr);
+    assert(ac->data == "aGVsbG8=");
+    assert(ac->mimeType == "audio/wav");
+
+    // Parse text still works
+    Json text_json = {{"type", "text"}, {"text", "hello"}};
+    auto block2 = client::parse_content_block(text_json);
+    assert(std::get_if<client::TextContent>(&block2) != nullptr);
+
+    // Parse image still works
+    Json img_json = {{"type", "image"}, {"data", "x"}, {"mimeType", "image/png"}};
+    auto block3 = client::parse_content_block(img_json);
+    assert(std::get_if<client::ImageContent>(&block3) != nullptr);
+
+    return 0;
+}

tests/content.cpp

@@ -17,5 +17,13 @@ int main()
     assert(ji.at("type") == "image");
     assert(ji.at("data") == "BASE64DATA");
     assert(ji.at("mimeType") == "image/png");
+
+    AudioContent audio;
+    audio.data = "AQID";
+    audio.mimeType = "audio/wav";
+    Json ja = audio;
+    assert(ja.at("type") == "audio");
+    assert(ja.at("data") == "AQID");
+    assert(ja.at("mimeType") == "audio/wav");
     return 0;
 }

tests/mcp/handler.cpp

@@ -69,5 +69,74 @@ int main()
                        {"params", Json{{"name", "any"}}}};
     auto prompt_get_resp = handler(prompt_get);
     assert(prompt_get_resp["result"]["messages"].is_array());
+
+    // ---- Tool version metadata in tools/list ----
+    {
+        tools::ToolManager tm2;
+        Json schema = {{"type", "object"}, {"properties", Json::object()}};
+        tools::Tool versioned{"versioned", schema, Json(),
+                              [](const Json&) { return 42; }};
+        versioned.set_version("2.0.0");
+        tm2.register_tool(versioned);
+        tools::Tool plain{"plain", schema, Json(),
+                          [](const Json&) { return 1; }};
+        tm2.register_tool(plain);
+
+        auto handler2 = mcp::make_mcp_handler("ver_test", "1.0.0", tm2);
+        auto list2 =
+            handler2(Json{{"jsonrpc", "2.0"}, {"id", 10}, {"method", "tools/list"}});
+        bool checked_versioned = false, checked_plain = false;
+        for (const auto& t : list2["result"]["tools"])
+        {
+            if (t["name"] == "versioned")
+            {
+                assert(t.contains("version"));
+                assert(t["version"] == "2.0.0");
+                checked_versioned = true;
+            }
+            if (t["name"] == "plain")
+            {
+                assert(!t.contains("version"));
+                checked_plain = true;
+            }
+        }
+        assert(checked_versioned);
+        assert(checked_plain);
+    }
+
+    // ---- Output schema: null vs non-null distinction ----
+    {
+        tools::ToolManager tm3;
+        Json schema = {{"type", "object"}, {"properties", Json::object()}};
+        // Json() = null → no outputSchema emitted
+        tools::Tool no_schema{"no_schema", schema, Json(),
+                              [](const Json&) { return 1; }};
+        // Json{{"type","object"}} → outputSchema present
+        tools::Tool with_schema{"with_schema", schema, Json{{"type", "object"}},
+                                [](const Json&) { return 1; }};
+        tm3.register_tool(no_schema);
+        tm3.register_tool(with_schema);
+
+        auto handler3 = mcp::make_mcp_handler("schema_test", "1.0.0", tm3);
+        auto list3 =
+            handler3(Json{{"jsonrpc", "2.0"}, {"id", 20}, {"method", "tools/list"}});
+        bool checked_no = false, checked_with = false;
+        for (const auto& t : list3["result"]["tools"])
+        {
+            if (t["name"] == "no_schema")
+            {
+                assert(!t.contains("outputSchema"));
+                checked_no = true;
+            }
+            if (t["name"] == "with_schema")
+            {
+                assert(t.contains("outputSchema"));
+                checked_with = true;
+            }
+        }
+        assert(checked_no);
+        assert(checked_with);
+    }
+
     return 0;
 }

tests/mcp/server_handler.cpp

@@ -21,11 +21,25 @@ int main()
                 return Json{{"content", content}};
             });
 
+    // audio_tool returns mixed text + audio content
+    s.route("audio_tool",
+            [](const Json&)
+            {
+                AudioContent audio;
+                audio.data = "aGVsbG8="; // base64("hello")
+                audio.mimeType = "audio/wav";
+                Json content =
+                    Json::array({TextContent{"text", "Audio attached"}, audio});
+                return Json{{"content", content}};
+            });
+
     std::vector<std::tuple<std::string, std::string, Json>> meta;
     meta.emplace_back("generate_chart", "Generates a chart",
                       Json{{"type", "object"},
                            {"properties", Json::object({{"title", Json{{"type", "string"}}}})},
                            {"required", Json::array({"title"})}});
+    meta.emplace_back("audio_tool", "Returns audio content",
+                      Json{{"type", "object"}, {"properties", Json::object()}});
 
     auto handler = mcp::make_mcp_handler("viz", "1.0.0", s, meta);
 
@@ -47,6 +61,20 @@ int main()
     assert(content[1]["type"] == "image");
     assert(content[1]["mimeType"] == "image/png");
 
+    // call audio_tool — verify audio block preserved through handler
+    Json audio_call = {
+        {"jsonrpc", "2.0"},
+        {"id", 10},
+        {"method", "tools/call"},
+        {"params", Json{{"name", "audio_tool"}, {"arguments", Json::object()}}}};
+    auto audio_resp = handler(audio_call);
+    auto audio_content = audio_resp["result"]["content"];
+    assert(audio_content.size() == 2);
+    assert(audio_content[0]["type"] == "text");
+    assert(audio_content[1]["type"] == "audio");
+    assert(audio_content[1]["data"] == "aGVsbG8=");
+    assert(audio_content[1]["mimeType"] == "audio/wav");
+
     // resources/list route
     s.route("resources/list",
             [](const Json&)