Update demo json_invoke

V2.41

Author: writePerfectCode

CMakeLists.txt

@@ -156,7 +156,7 @@ if(LLM_INVOKE_CPP_BUILD_EXAMPLES)
     endif()
 
     add_executable(json_invoke_demo examples/json_invoke/json_invoke_demo.cpp)
-    target_link_libraries(json_invoke_demo PRIVATE llm_invoke_cpp::json_invoke)
+    target_link_libraries(json_invoke_demo PRIVATE llm_invoke_cpp::json_invoke examples_fs_tools)
 
     add_executable(json_stateful_demo examples/json_stateful/json_stateful_demo.cpp)
     target_link_libraries(json_stateful_demo PRIVATE llm_invoke_cpp::json_session_invoke)

SCHEMA_TRAITS.md

@@ -446,8 +446,8 @@ In this repository, keep `schema_traits<T>` next to related type support code.
 
 Examples:
 
-1. `examples/json_invoke/person_support.hpp` holds both `json_traits<Person>` and `schema_traits<Person>`.
-2. Enum mappings live in `examples/json_invoke/priority_support.hpp`.
+1. `tests/json_invoke_tests.cpp` co-locates `json_traits<Person>` and `schema_traits<Person>` for snapshot coverage.
+2. The same file co-locates enum mappings via `enum_traits<Priority>`.
 
 That organization is easier for both humans and LLMs to follow than scattering traits across many unrelated files.
 

examples/json_invoke/README.md

@@ -1,12 +1,8 @@
 # JSON Invoke Demo
 
-This example demonstrates the `json_invoke` library: a JSON-based function invocation system that bridges C++ functions with LLM-style tool calling.
+This example demonstrates the `json_invoke` library: register native C++ functions once, then invoke them through JSON payloads (including LLM-style tool call format).
 
-Functions are registered and invoked via JSON payloads, supporting:
-- Standard JSON request format
-- LLM-compatible tool call format (matching Claude, ChatGPT conventions)
-- Complex types (structs, arrays, nested objects)
-- Custom type serialization
+The scenario is the same filesystem workflow used across the examples: write a file, read it back, inspect metadata, list a directory, and search text.
 
 ## Build
 
@@ -29,8 +25,9 @@ Linux/macOS:
 
 ## Features Demonstrated
 
-- Invoke functions by JSON request with typed parameters
-- Support for LLM tool-call request format with JSON-encoded arguments
-- Serialize and deserialize complex C++ types to/from JSON
-- Invoke functions and get results back as C++ types or JSON
-- Process nested objects and arrays in function arguments
+- Register free functions as JSON-callable tools
+- Invoke with standard JSON request format (`name` + `args`)
+- Invoke with LLM-compatible payload (`type=function`, JSON string `arguments`)
+- Read simple results as typed C++ values (`std::string`)
+- Read the same tool results as generic JSON
+- Export all tool schemas for host-side inspection

examples/json_invoke/json_invoke_demo.cpp

@@ -1,195 +1,89 @@
 #include <iostream>
-#include <optional>
 #include <string>
-#include "person_support.hpp"
-#include "priority_support.hpp"
+
+#include <filesystem_tools.hpp>
 #include <json_invoke/json_invoke.hpp>
 
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(NumberedLine, line_number, content);
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(FileEntry, name, type, size_bytes, last_modified);
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(SearchMatch, path, line_number, line);
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(FileInfo, path, type, size_bytes, last_modified, exists);
+
 int main()
 {
     json_invoke::JsonInvokeAdapterThreadSafe adapter;
 
-    adapter.registerFunction("add", json_invoke::readOnly([](int x, int y) { return x + y; }), "Add two integers.");
-    adapter.registerFunction("getPerson", json_invoke::readOnly(getPerson), "Construct one person.");
-    adapter.registerFunction(
-        "describePerson",
-        json_invoke::readOnly(&Person::describe),
-        json_invoke::FunctionMetadata{{"person"}, "Call Person::describe() for one person."});
     adapter.registerFunction(
-        "countPeopleAtLeastAge",
-        json_invoke::readOnly(countPeopleAtLeastAge),
-        json_invoke::FunctionMetadata{{"people", "minimum_age"}, "Count how many people in a JSON roster meet a minimum age."});
+        "write_file",
+        json_invoke::mutating(writeFile),
+        json_invoke::FunctionMetadata{{"path", "content", "overwrite"}, "Write text content to a file."});
     adapter.registerFunction(
-        "countPeopleAtLeastAgeByTeam",
-        json_invoke::readOnly(countPeopleAtLeastAgeByTeam),
-        json_invoke::FunctionMetadata{
-            {"team_rosters", "minimum_age"},
-            "Count how many people in each team roster meet a minimum age."});
+        "read_file",
+        json_invoke::readOnly(readFile),
+        json_invoke::FunctionMetadata{{"path"}, "Read the full text content of a file."});
     adapter.registerFunction(
-        "oldestPersonByQueue",
-        json_invoke::readOnly(oldestPersonByQueue),
-        json_invoke::FunctionMetadata{
-            {"queue_rosters"},
-            "Find the oldest person in each support queue."});
+        "get_file_info",
+        json_invoke::readOnly(getFileInfo),
+        json_invoke::FunctionMetadata{{"path"}, "Return metadata for one path."});
     adapter.registerFunction(
-        "displayNickname",
-        json_invoke::readOnly([](std::optional<std::string> nickname) {
-            return nickname.value_or("anonymous");
-        }),
-        json_invoke::FunctionMetadata{{"nickname"}, "Return the nickname or a default when omitted."});
+        "list_directory",
+        json_invoke::readOnly(listDirectory),
+        json_invoke::FunctionMetadata{{"path"}, "List immediate directory entries."});
     adapter.registerFunction(
-        "recommendIncidentPriority",
-        json_invoke::readOnly(recommendIncidentPriority),
-        json_invoke::FunctionMetadata{
-            {"requested_priority", "customer_blocked", "production_impact", "affected_users"},
-            "Recommend an incident priority from request urgency and customer impact."});
-
-    //#1
-    std::cout << "--- Invoke add as int ---" << std::endl;
-    int sum = adapter.invoke({
-        {"name", "add"},
-        {"args", {8, 13}},
-    });
-    std::cout << sum << std::endl;
+        "search_files",
+        json_invoke::readOnly(searchFiles),
+        json_invoke::FunctionMetadata{{"directory", "pattern", "recursive"}, "Search text files for a literal pattern."});
 
-    //#2
-    std::cout << "\n--- Invoke LLM-style payload as int ---" << std::endl;
-    json_invoke::json llm_tool_call_request = {
-        {"type", "function"},
-        {"function", {
-            {"name", "add"},
-            {"arguments", R"({"arg0":21,"arg1":9})"},
+    std::cout << "--- 1) write_file (JSON request -> typed return) ---" << std::endl;
+    std::string write_result = adapter.invoke({
+        {"name", "write_file"},
+        {"args", {
+            {"path", "build/_json_invoke_scratch.txt"},
+            {"content", "alpha\nbeta\ngamma\n"},
+            {"overwrite", true},
         }},
-    };
-    int llm_sum = adapter.invoke(llm_tool_call_request);
-    std::cout << llm_sum << std::endl;
-
-    //#3
-    std::cout << "\n--- Invoke getPerson get Person object ---" << std::endl;
-    Person person = adapter.invoke({
-        {"name", "getPerson"},
     });
-    std::cout << person.describe() << std::endl;
+    std::cout << write_result << std::endl;
 
-    //#4
-    std::cout << "\n--- Invoke describePerson get std::string ---" << std::endl;
-    std::string description = adapter.invoke({
-        {"name", "describePerson"},
-        {"args", {person}},
+    std::cout << "\n--- 2) read_file (JSON request -> typed string) ---" << std::endl;
+    std::string content = adapter.invoke({
+        {"name", "read_file"},
+        {"args", {{"path", "build/_json_invoke_scratch.txt"}}},
     });
-    std::cout << description << std::endl;
+    std::cout << content;
 
-    //#5
-    std::cout << "\n--- Invoke getPerson get Person as Json ---" << std::endl;
-    json_invoke::json personJson = adapter.invoke({
-        {"name", "getPerson"},
+    std::cout << "\n--- 3) get_file_info (as JSON) ---" << std::endl;
+    json_invoke::json info_json = adapter.invoke({
+        {"name", "get_file_info"},
+        {"args", {{"path", "build/_json_invoke_scratch.txt"}}},
     });
-    std::cout << personJson.dump(2) << std::endl;
-
-    //#6
-    std::cout << "\n--- Invoke describePerson using json object ---" << std::endl;
-    json_invoke::json descriptionRequest = {
-        {"name", "describePerson"},
-        {"args", {personJson}},
-    };
-    json_invoke::json descriptionJson = adapter.invoke(descriptionRequest);
-    std::cout << descriptionJson.dump(2) << std::endl;
-
-    std::cout << "\n--- Count people from array of JSON objects ---" << std::endl;
-    json_invoke::json rosterRequest = {
-        {"name", "countPeopleAtLeastAge"},
-        {"args", {
-            {"people", json_invoke::json::array({
-                personJson,
-                json_invoke::json{{"name", "Bob"}, {"age", 17}},
-                json_invoke::json{{"name", "Cara"}, {"age", 41}},
-            })},
-            {"minimum_age", 21},
-        }},
-    };
-    int adultCount = adapter.invoke(rosterRequest);
-    std::cout << adultCount << std::endl;
+    std::cout << info_json.dump(2) << std::endl;
 
-    std::cout << "\n--- Count people by team from dictionary of rosters ---" << std::endl;
-    json_invoke::json teamRosterRequest = {
-        {"name", "countPeopleAtLeastAgeByTeam"},
-        {"args", {
-            {"team_rosters", {
-                {"support", json_invoke::json::array({
-                    personJson,
-                    json_invoke::json{{"name", "Bob"}, {"age", 17}},
-                })},
-                {"platform", json_invoke::json::array({
-                    json_invoke::json{{"name", "Cara"}, {"age", 41}},
-                    json_invoke::json{{"name", "Dylan"}, {"age", 29}},
-                    json_invoke::json{{"name", "Eva"}, {"age", 18}},
-                })},
-            }},
-            {"minimum_age", 21},
+    std::cout << "\n--- 4) list_directory (LLM-style payload) ---" << std::endl;
+    json_invoke::json llm_tool_call_request = {
+        {"type", "function"},
+        {"function", {
+            {"name", "list_directory"},
+            {"arguments", R"({"path":"build"})"},
         }},
     };
-    json_invoke::json teamCounts = adapter.invoke(teamRosterRequest);
-    std::cout << teamCounts.dump(2) << std::endl;
+    json_invoke::json entries_json = adapter.invoke(llm_tool_call_request);
+    std::cout << entries_json.dump(2) << std::endl;
 
-    std::cout << "\n--- Find oldest person by queue from unordered dictionary ---" << std::endl;
-    json_invoke::json queueRequest = {
-        {"name", "oldestPersonByQueue"},
+    std::cout << "\n--- 5) search_files (as JSON) ---" << std::endl;
+    json_invoke::json matches_json = adapter.invoke({
+        {"name", "search_files"},
         {"args", {
-            {"queue_rosters", {
-                {"billing", json_invoke::json::array({
-                    json_invoke::json{{"name", "Mia"}, {"age", 26}},
-                    json_invoke::json{{"name", "Noah"}, {"age", 31}},
-                })},
-                {"vip", json_invoke::json::array({
-                    personJson,
-                    json_invoke::json{{"name", "Olivia"}, {"age", 45}},
-                })},
-            }},
+            {"directory", "build"},
+            {"pattern", "beta"},
+            {"recursive", false},
         }},
-    };
-    json_invoke::json oldestByQueue = adapter.invoke(queueRequest);
-    std::cout << oldestByQueue.dump(2) << std::endl;
-
-    std::cout << "\n--- Invoke displayNickname without optional arg ---" << std::endl;
-    std::string nickname = adapter.invoke({
-        {"name", "displayNickname"},
-        {"args", json_invoke::json::object()},
-    });
-    std::cout << nickname << std::endl;
-
-    std::cout << "\n--- Invoke displayNickname with optional arg ---" << std::endl;
-    std::string nicknameWithArg = adapter.invoke({
-        {"name", "displayNickname"},
-        {"args", {"tom"}},
     });
-    std::cout << nicknameWithArg << std::endl;
-
-    std::cout << "\n--- Recommend incident priority from named JSON args ---" << std::endl;
-    json_invoke::json recommendedPriorityJson = adapter.invoke({
-        {"name", "recommendIncidentPriority"},
-        {"args", {
-            {"requested_priority", "low"},
-            {"customer_blocked", true},
-            {"production_impact", false},
-            {"affected_users", 120},
-        }},
-    });
-    std::cout << recommendedPriorityJson.dump(2) << std::endl;
-
-    std::cout << "\n--- Recommend incident priority as typed enum ---" << std::endl;
-    Priority recommendedPriority = adapter.invoke({
-        {"name", "recommendIncidentPriority"},
-        {"args", {
-            {"requested_priority", "normal"},
-            {"customer_blocked", true},
-            {"production_impact", true},
-            {"affected_users", 320},
-        }},
-    });
-    std::cout << func_registry::enum_name(recommendedPriority) << std::endl;
-
-    //std::cout << "\n--- Tool summaries JSON ---" << std::endl;
-    //std::cout << adapter.getAllToolSummariesJson().dump(2) << std::endl;
+    std::cout << "matches: " << matches_json.size() << std::endl;
+    if (!matches_json.empty())
+    {
+        std::cout << "first match: " << matches_json.front().dump() << std::endl;
+    }
 
     std::cout << "\n--- Tool schemas JSON ---" << std::endl;
     std::cout << adapter.getAllToolSchemasJson().dump(2) << std::endl;