Post-Merge refactoring

Author: bandoti

common/chat.cpp

@@ -291,9 +291,11 @@ std::string common_chat_format_single(
         const std::vector<common_chat_msg> & past_msg,
         const common_chat_msg & new_msg,
         bool add_ass,
-        bool use_jinja) {
+        bool use_jinja,
+        const struct common_chat_templates_inputs * input_extra,
+        struct common_chat_params * out_params) {
 
-    common_chat_templates_inputs inputs;
+    common_chat_templates_inputs inputs = input_extra ? *input_extra : common_chat_templates_inputs();
     inputs.use_jinja = use_jinja;
 
     std::string fmt_past_msg;
@@ -310,9 +312,13 @@ std::string common_chat_format_single(
     // format chat with new_msg
     inputs.messages.push_back(new_msg);
     inputs.add_generation_prompt = add_ass;
-    auto fmt_new_msg = common_chat_templates_apply(tmpls, inputs).prompt;
+    auto chat_params = common_chat_templates_apply(tmpls, inputs);
+    auto fmt_new_msg = chat_params.prompt;
     // get the diff part
     ss << fmt_new_msg.substr(fmt_past_msg.size(), fmt_new_msg.size() - fmt_past_msg.size());
+    if (out_params) {
+        *out_params = std::move(chat_params);
+    }
     return ss.str();
 }
 

common/chat.h

@@ -111,7 +111,9 @@ std::string common_chat_format_single(
         const std::vector<common_chat_msg> & past_msg,
         const common_chat_msg & new_msg,
         bool add_ass,
-        bool use_jinja);
+        bool use_jinja,
+        const struct common_chat_templates_inputs * input_extra = nullptr,
+        struct common_chat_params * out_params = nullptr);
 
 // Returns an example of formatted chat
 std::string common_chat_format_example(

common/common.cpp

@@ -12,6 +12,7 @@
 #include "json.hpp"
 #include "json-schema-to-grammar.h"
 #include "llama.h"
+#include "chat.h"
 
 #include <algorithm>
 #include <cinttypes>

common/toolcall/handler.cpp

@@ -1,82 +1,74 @@
 
 #include <json.hpp>
 #include "handler.hpp"
-#include "params.hpp"
 
 #ifdef LLAMA_USE_CURL
 #    include "mcp_sse_transport.hpp"
 #endif
 
 #include "mcp_stdio_transport.hpp"
 
-using json = toolcall::json;
+using json = nlohmann::json;
 
 std::shared_ptr<toolcall::handler> toolcall::create_handler(const toolcall::params & params) {
-    std::shared_ptr<toolcall::handler> result;
+    std::shared_ptr<toolcall::handler> handler;
 
     auto tools = params.tools();
     auto choice = params.choice();
-    bool has_uri = std::holds_alternative<std::string>(tools);
-    if (has_uri) {
+    if (params.has_uri()) {
 #ifdef LLAMA_USE_CURL
-        auto tools_str = std::get<std::string>(tools);
-        if (! tools_str.empty()) {
-            result.reset(new toolcall::handler(std::make_unique<toolcall::mcp_impl>(tools_str, choice)));
-        }
+        handler.reset(new toolcall::handler(std::make_unique<toolcall::mcp_impl>(tools, choice)));
 #endif
     } else {
-        auto tools_ptr = std::get<toolcall::json_ptr>(tools);
-        if (tools_ptr != nullptr) {
-            result.reset(new toolcall::handler(std::make_unique<toolcall::loopback_impl>(*tools_ptr, choice)));
-        }
+        handler.reset(new toolcall::handler(std::make_unique<toolcall::loopback_impl>(tools, choice)));
     }
 
-    return result;
+    return handler;
 }
 
-json toolcall::handler::tool_list() {
+std::string toolcall::handler::tool_list() {
     return impl_->tool_list();
 }
 
-toolcall::action toolcall::handler::call(const json & request, json & response) {
+toolcall::action toolcall::handler::call(const std::string & request, std::string & response) {
     last_action_ = impl_->call(request, response);
     return last_action_;
 }
 
-const toolcall::tool_choice_t & toolcall::handler::tool_choice() const {
+const std::string & toolcall::handler::tool_choice() const {
     return impl_->tool_choice();
 }
 toolcall::action toolcall::handler::last_action() const {
     return last_action_;
 }
 
 #ifdef LLAMA_USE_CURL
-toolcall::mcp_impl::mcp_impl(std::string server_uri, tool_choice_t tool_choice)
+toolcall::mcp_impl::mcp_impl(std::string server_uri, std::string tool_choice)
     : handler_impl(tool_choice),
       transport_(new mcp_sse_transport(server_uri))
 {
     transport_->start();
 }
 #else
-toolcall::mcp_impl::mcp_impl(std::string /*server_uri*/, tool_choice_t tool_choice)
+toolcall::mcp_impl::mcp_impl(std::string /*server_uri*/, std::string tool_choice)
     : handler_impl(tool_choice)
 {
 }
 #endif
 
-toolcall::mcp_impl::mcp_impl(std::vector<std::string> argv, tool_choice_t tool_choice)
+toolcall::mcp_impl::mcp_impl(std::vector<std::string> argv, std::string tool_choice)
     : handler_impl(tool_choice),
       transport_(new mcp_stdio_transport(argv))
 {
     transport_->start();
 }
 
-json toolcall::mcp_impl::tool_list() {
+std::string toolcall::mcp_impl::tool_list() {
     // Construct tools/list call and send to transport
     return json{};// TODO
 }
 
-toolcall::action toolcall::mcp_impl::call(const json & /*request*/, json & /*response*/) {
+toolcall::action toolcall::mcp_impl::call(const std::string & /*request*/, std::string & /*response*/) {
     // Construct tool call and send to transport
     return toolcall::ACCEPT; // TODO
 }

common/toolcall/handler.hpp

@@ -1,18 +1,13 @@
 #pragma once
 
-#include <json.hpp> // TODO: remove dependence on this
-#include "params.hpp" // TODO: make foreward decl.
+#include "params.hpp"
 #include <string>
 #include <variant>
 #include <memory>
+#include <vector>
 
 namespace toolcall
 {
-    using json = nlohmann::ordered_json;
-    using json_ptr = std::shared_ptr<json>;
-    using tools_t = std::variant<std::string, json_ptr>;
-    using tool_choice_t = std::variant<std::string, json_ptr>;
-
     enum action {
         ACCEPT,
         PENDING,
@@ -26,9 +21,9 @@ namespace toolcall
 
         handler(std::unique_ptr<handler_impl> impl) : impl_(std::move(impl)) {}
 
-        json tool_list();
-        action call(const json & request, json & response);
-        const tool_choice_t & tool_choice() const;
+        std::string tool_list();
+        action call(const std::string & request, std::string & response);
+        const std::string & tool_choice() const;
         action last_action() const;
 
     private:
@@ -40,45 +35,45 @@ namespace toolcall
 
     class handler_impl {
     public:
-        handler_impl(tool_choice_t tool_choice)
+        handler_impl(std::string tool_choice)
             : tool_choice_(std::move(tool_choice)) {}
 
         virtual ~handler_impl() = default;
-        virtual json tool_list() = 0;
-        virtual action call(const json & request, json & response) = 0;
+        virtual std::string tool_list() = 0;
+        virtual action call(const std::string & request, std::string & response) = 0;
 
-        const tool_choice_t & tool_choice() const { return tool_choice_; }
+        const std::string & tool_choice() const { return tool_choice_; }
 
     protected:
-        tool_choice_t tool_choice_;
+        std::string tool_choice_;
     };
 
     class loopback_impl : public handler_impl {
     public:
-        loopback_impl(json tools, tool_choice_t tool_choice)
+        loopback_impl(std::string tools, std::string tool_choice)
             : handler_impl(tool_choice), tools_(std::move(tools)) {}
 
-        virtual json tool_list() override {
+        virtual std::string tool_list() override {
             return tools_;
         }
 
-        virtual action call(const json & request, json & response) override {
+        virtual action call(const std::string & request, std::string & response) override {
             response = request;
             return toolcall::DEFER;
         }
 
     private:
-        json tools_;
+        std::string tools_;
     };
 
     class mcp_transport;
     class mcp_impl : public handler_impl {
     public:
-        mcp_impl(std::string server_uri, tool_choice_t tool_choice);
-        mcp_impl(std::vector<std::string> argv, tool_choice_t tool_choice);
+        mcp_impl(std::string server_uri, std::string tool_choice);
+        mcp_impl(std::vector<std::string> argv, std::string tool_choice);
 
-        virtual json tool_list() override;
-        virtual action call(const json & request, json & response) override;
+        virtual std::string tool_list() override;
+        virtual action call(const std::string & request, std::string & response) override;
 
     private:
         std::unique_ptr<mcp_transport> transport_;

common/toolcall/params.cpp

@@ -1,9 +1,9 @@
 
-#include "../json.hpp" // Must come before params due to forward decl.
 #include "params.hpp"
 #include <stdexcept>
+#include <json.hpp>
 
-using json = nlohmann::ordered_json;
+using json = nlohmann::json;
 
 static bool starts_with(const std::string & str, const std::string & prefix) {
     return str.size() >= prefix.size()
@@ -17,25 +17,25 @@ toolcall::params::params(std::string tools, std::string choice) {
 
 void toolcall::params::tools(std::string tools) {
     try {
-        if (tools.empty()) {
-            tools_ = std::move(tools);
-
-        } else if (starts_with(tools, "mcp+http")) {
-#ifdef LLAMA_USE_CURL
-            tools_ = std::move(tools);
-#else
-            throw std::invalid_argument(
-                "Model Context Protocol (MCP) only works when llama.cpp is compiled with libcurl");
-#endif
-        } else {
-            tools_ = std::make_shared<json>(json::parse(tools));
-            auto tools_ptr = std::get<std::shared_ptr<json>>(tools_);
-            if (! tools_ptr->is_array()) {
+        if (! tools.empty()) {
+            if (starts_with(tools, "mcp+http")) {
+#ifndef LLAMA_USE_CURL
                 throw std::invalid_argument(
-                    "tools must be a URL of the form \"mcp+http(s)://hostname[:port]/\""
-                    ", or a valid JSON array containing tool definitions");
+                    "Model Context Protocol (MCP) only works when llama.cpp is compiled with libcurl");
+#endif
+                has_uri_ = true;
+
+            } else {
+                json j = json::parse(tools); // Just for early validation
+                if (! j.is_array()) {
+                    throw std::invalid_argument(
+                        "tools must be a URL of the form \"mcp+http(s)://hostname[:port]/\""
+                        ", or a valid JSON array containing tool definitions");
+                }
+                has_uri_ = false;
             }
         }
+        tools_ = std::move(tools);
 
     } catch (const json::exception & err) {
         throw std::invalid_argument(err.what());
@@ -48,12 +48,8 @@ void toolcall::params::choice(std::string choice) {
             tool_choice_ = std::move(choice);
 
         } else {
-            auto choice_ptr = std::make_shared<json>(json::parse(choice));
-            tool_choice_ = choice_ptr;
-            if (! choice_ptr->is_object()) {
-                throw std::invalid_argument(
-                    "tool choice must be a valid JSON object, \"auto\", \"required\", or \"none\"");
-            }
+            throw std::invalid_argument(
+                "tool choice must be set to \"auto\", \"required\", or \"none\"");
         }
 
     } catch (const json::exception & err) {
@@ -62,10 +58,5 @@ void toolcall::params::choice(std::string choice) {
 }
 
 toolcall::params::operator bool() const  {
-    if (std::holds_alternative<std::string>(tools_)) {
-        return ! std::get<std::string>(tools_).empty();
-
-    } else {
-        return std::get<json_ptr>(tools_) != nullptr;
-    }
+    return ! tools_.empty();
 }

common/toolcall/params.hpp

@@ -4,17 +4,10 @@
 #include <variant>
 #include <memory>
 
-#include <json.hpp> // TODO: switch to foreward decl.
-// namespace nlohmann { class ordered_json; }
-
 namespace toolcall
 {
     class params {
     public:
-        using json_ptr = std::shared_ptr<nlohmann::ordered_json>;
-        using tools_t = std::variant<std::string, json_ptr>;
-        using tool_choice_t = std::variant<std::string, json_ptr>;
-
         params(std::string tools = "", std::string choice = "auto");
 
         params(const params & other) = default;
@@ -25,13 +18,16 @@ namespace toolcall
         operator bool() const;
 
         void tools(std::string tools);
-        const tools_t tools() const { return tools_; }
+        const std::string & tools() const { return tools_; }
 
         void choice(std::string choice);
-        const tool_choice_t & choice() const { return tool_choice_; }
+        const std::string & choice() const { return tool_choice_; }
+
+        bool has_uri() const { return has_uri_; }
 
     private:
-        tools_t tools_;
-        tool_choice_t tool_choice_;
+        std::string tools_;
+        std::string tool_choice_;
+        bool has_uri_;
     };
 }