completion.hpp

Go to the documentation of this file.

// Copyright (c) 2025 [caomengxuan666]
 
#pragma once
 
 
#include <cstddef>
#include <cstdint>
#include <limits>
#include <map>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
#include "cxxmcp/core/result.hpp"
#include "cxxmcp/protocol/reflect.hpp"
#include "cxxmcp/protocol/types.hpp"
 
namespace mcp::protocol {
 
struct CompletionReference {
  std::string type;
  std::string name;
  std::optional<std::string> uri;
  std::string title;
  Json extensions = Json::object();
};
 
inline CompletionReference prompt_completion_reference(std::string name) {
  return CompletionReference{"ref/prompt", std::move(name)};
}
 
inline CompletionReference resource_completion_reference(std::string uri) {
  CompletionReference ref;
  ref.type = "ref/resource";
  ref.name = uri;
  ref.uri = std::move(uri);
  return ref;
}
 
struct CompletionArgument {
  std::string name;
  std::string value;
  Json extensions = Json::object();
};
 
template <>
struct Reflect<CompletionArgument> {
  static constexpr bool defined = true;
  static auto fields() {
    return std::make_tuple(
        field("name", &CompletionArgument::name),
        field("value", &CompletionArgument::value),
        extensions_field(&CompletionArgument::extensions, {"name", "value"}));
  }
  static std::vector<std::string> known_keys() { return {"name", "value"}; }
};
 
struct CompletionContext {
  std::optional<std::map<std::string, std::string>> arguments;
};
 
template <>
struct Reflect<CompletionContext> {
  static constexpr bool defined = true;
  static auto fields() {
    return std::make_tuple(field("arguments", &CompletionContext::arguments));
  }
  static std::vector<std::string> known_keys() { return {"arguments"}; }
};
 
struct CompleteParams {
  CompletionReference ref;
  CompletionArgument argument;
  std::optional<CompletionContext> typed_context;
  Json context = Json::object();
  std::optional<Json> meta;
  Json extensions = Json::object();
};
 
struct CompletionResult {
  static constexpr std::size_t kMaxValues = 100;
  std::vector<std::string> values;
  std::optional<int> total;
  std::optional<bool> has_more;
  Json extensions = Json::object();
 
  bool has_more_results() const noexcept { return has_more.value_or(false); }
};
 
struct CompleteResult {
  CompletionResult completion;
  std::optional<Json> meta;
  Json extensions = Json::object();
};
 
inline core::Error completion_json_error(std::string message) {
  return core::Error{
      static_cast<int>(ErrorCode::InvalidRequest), std::move(message), {}};
}
 
inline Json completion_reference_to_json(const CompletionReference& ref) {
  Json json = Json::object();
  json["type"] = ref.type;
  if (ref.uri.has_value()) {
    json["uri"] = *ref.uri;
  } else if (!ref.name.empty()) {
    json["name"] = ref.name;
  }
  if (!ref.title.empty()) {
    json["title"] = ref.title;
  }
  append_json_extensions(json, ref.extensions);
  return json;
}
 
inline core::Result<CompletionReference> completion_reference_from_json(
    const Json& json) {
  if (!json.is_object()) {
    return mcp::core::unexpected(
        completion_json_error("completion ref must be an object"));
  }
  if (!json.contains("type") || !json.at("type").is_string()) {
    return mcp::core::unexpected(
        completion_json_error("completion ref requires a string type"));
  }
  CompletionReference ref;
  ref.type = json.at("type").get<std::string>();
  if (ref.type == "ref/prompt") {
    if (!json.contains("name") || !json.at("name").is_string()) {
      return mcp::core::unexpected(
          completion_json_error("completion prompt ref requires string name"));
    }
    ref.name = json.at("name").get<std::string>();
    if (json.contains("uri")) {
      return mcp::core::unexpected(
          completion_json_error("completion prompt ref must not contain uri"));
    }
  } else if (ref.type == "ref/resource") {
    if (!json.contains("uri") || !json.at("uri").is_string()) {
      return mcp::core::unexpected(
          completion_json_error("completion resource ref requires string uri"));
    }
    ref.uri = json.at("uri").get<std::string>();
    if (json.contains("name")) {
      return mcp::core::unexpected(completion_json_error(
          "completion resource ref must not contain name"));
    }
  } else {
    return mcp::core::unexpected(
        completion_json_error("completion ref type is not supported"));
  }
  if (json.contains("title")) {
    if (ref.type != "ref/prompt") {
      return mcp::core::unexpected(completion_json_error(
          "completion resource ref must not contain title"));
    }
    if (!json.at("title").is_string()) {
      return mcp::core::unexpected(
          completion_json_error("completion ref title must be a string"));
    }
    ref.title = json.at("title").get<std::string>();
  }
  ref.extensions =
      collect_json_extensions(json, {"type", "name", "uri", "title"});
  return ref;
}
 
inline Json completion_argument_to_json(const CompletionArgument& argument) {
  return reflect_to_json(argument);
}
 
inline core::Result<CompletionArgument> completion_argument_from_json(
    const Json& json) {
  return reflect_from_json<CompletionArgument>(json);
}
 
inline Json completion_context_to_json(const CompletionContext& context) {
  return reflect_to_json(context);
}
 
inline core::Result<CompletionContext> completion_context_from_json(
    const Json& json) {
  return reflect_from_json<CompletionContext>(json);
}
 
inline Json complete_params_to_json(const CompleteParams& params) {
  Json json = Json::object();
  json["ref"] = completion_reference_to_json(params.ref);
  json["argument"] = completion_argument_to_json(params.argument);
  if (params.typed_context.has_value()) {
    json["context"] = completion_context_to_json(*params.typed_context);
  } else if (!params.context.empty()) {
    json["context"] = params.context;
  }
  if (params.meta.has_value()) {
    json["_meta"] = *params.meta;
  }
  append_json_extensions(json, params.extensions);
  return json;
}
 
inline core::Result<CompleteParams> complete_params_from_json(
    const Json& json) {
  if (!json.is_object()) {
    return mcp::core::unexpected(
        completion_json_error("completion params must be an object"));
  }
  if (!json.contains("ref")) {
    return mcp::core::unexpected(
        completion_json_error("completion params require ref"));
  }
  if (!json.contains("argument")) {
    return mcp::core::unexpected(
        completion_json_error("completion params require argument"));
  }
 
  const auto ref = completion_reference_from_json(json.at("ref"));
  if (!ref) {
    return mcp::core::unexpected(ref.error());
  }
  const auto argument = completion_argument_from_json(json.at("argument"));
  if (!argument) {
    return mcp::core::unexpected(argument.error());
  }
 
  CompleteParams params;
  params.ref = *ref;
  params.argument = *argument;
  if (json.contains("context")) {
    if (!json.at("context").is_object()) {
      return mcp::core::unexpected(
          completion_json_error("completion context must be an object"));
    }
    params.context = json.at("context");
    if (json.at("context").contains("arguments")) {
      const auto typed = completion_context_from_json(json.at("context"));
      if (typed) {
        params.typed_context = *typed;
      }
    }
  }
  if (json.contains("_meta")) {
    if (!json.at("_meta").is_object()) {
      return mcp::core::unexpected(
          completion_json_error("completion _meta must be an object"));
    }
    params.meta = json.at("_meta");
  }
  params.extensions =
      collect_json_extensions(json, {"ref", "argument", "context", "_meta"});
  return params;
}
 
inline Json completion_result_to_json(const CompletionResult& completion) {
  Json json = Json::object();
  json["values"] = completion.values;
  if (completion.total.has_value()) {
    json["total"] = *completion.total;
  }
  if (completion.has_more.has_value()) {
    json["hasMore"] = *completion.has_more;
  }
  append_json_extensions(json, completion.extensions);
  return json;
}
 
inline core::Result<CompletionResult> completion_result_from_json(
    const Json& json) {
  if (!json.is_object()) {
    return mcp::core::unexpected(
        completion_json_error("completion result must be an object"));
  }
  if (!json.contains("values") || !json.at("values").is_array()) {
    return mcp::core::unexpected(
        completion_json_error("completion result requires a values array"));
  }
  if (json.at("values").size() > CompletionResult::kMaxValues) {
    return mcp::core::unexpected(
        completion_json_error("completion result has too many values"));
  }
 
  CompletionResult completion;
  for (const auto& item : json.at("values")) {
    if (!item.is_string()) {
      return mcp::core::unexpected(
          completion_json_error("completion values must be strings"));
    }
    completion.values.push_back(item.get<std::string>());
  }
  if (json.contains("total")) {
    if (!json.at("total").is_number_integer()) {
      return mcp::core::unexpected(completion_json_error(
          "completion total must be a non-negative integer"));
    }
    const auto total = json.at("total").get<std::int64_t>();
    if (total < 0 || total > std::numeric_limits<int>::max()) {
      return mcp::core::unexpected(completion_json_error(
          "completion total must be a non-negative integer"));
    }
    completion.total = static_cast<int>(total);
  }
  if (json.contains("hasMore")) {
    if (!json.at("hasMore").is_boolean()) {
      return mcp::core::unexpected(
          completion_json_error("completion hasMore must be a boolean"));
    }
    completion.has_more = json.at("hasMore").get<bool>();
  }
  completion.extensions =
      collect_json_extensions(json, {"values", "total", "hasMore"});
  return completion;
}
 
inline Json complete_result_to_json(const CompleteResult& result) {
  Json json =
      Json{{"completion", completion_result_to_json(result.completion)}};
  if (result.meta.has_value()) {
    json["_meta"] = *result.meta;
  }
  append_json_extensions(json, result.extensions);
  return json;
}
 
inline core::Result<CompleteResult> complete_result_from_json(
    const Json& json) {
  if (!json.is_object()) {
    return mcp::core::unexpected(
        completion_json_error("completion result envelope must be an object"));
  }
  if (!json.contains("completion")) {
    return mcp::core::unexpected(completion_json_error(
        "completion result envelope requires completion"));
  }
  const auto completion = completion_result_from_json(json.at("completion"));
  if (!completion) {
    return mcp::core::unexpected(completion.error());
  }
  CompleteResult result;
  result.completion = *completion;
  if (json.contains("_meta")) {
    if (!json.at("_meta").is_object()) {
      return mcp::core::unexpected(
          completion_json_error("completion result _meta must be an object"));
    }
    result.meta = json.at("_meta");
  }
  result.extensions = collect_json_extensions(json, {"completion", "_meta"});
  return result;
}
 
}  // namespace mcp::protocol