feat: add assistants

Author: namchuai

engine/common/assistant.h

@@ -0,0 +1,157 @@
+#pragma once
+
+#include <string>
+#include "common/assistant_tool.h"
+#include "common/thread_tool_resources.h"
+#include "common/variant_map.h"
+#include "utils/result.hpp"
+
+namespace OpenAi {
+// Deprecated. After jan's migration, we should remove this struct
+struct JanAssistant : JsonSerializable {
+  std::string id;
+
+  std::string name;
+
+  std::string object = "assistant";
+
+  uint32_t created_at;
+
+  Json::Value tools;
+
+  Json::Value model;
+
+  std::string instructions;
+
+  ~JanAssistant() = default;
+
+  cpp::result<Json::Value, std::string> ToJson() override {
+    try {
+      Json::Value json;
+
+      json["id"] = id;
+      json["name"] = name;
+      json["object"] = object;
+      json["created_at"] = created_at;
+
+      json["tools"] = tools;
+      json["model"] = model;
+      json["instructions"] = instructions;
+
+      return json;
+    } catch (const std::exception& e) {
+      return cpp::fail(std::string("ToJson failed: ") + e.what());
+    }
+  }
+
+  static cpp::result<JanAssistant, std::string> FromJson(Json::Value&& json) {
+    if (json.empty()) {
+      return cpp::fail("Empty JSON");
+    }
+
+    JanAssistant assistant;
+    if (json.isMember("assistant_id")) {
+      assistant.id = json["assistant_id"].asString();
+    } else {
+      assistant.id = json["id"].asString();
+    }
+
+    if (json.isMember("assistant_name")) {
+      assistant.name = json["assistant_name"].asString();
+    } else {
+      assistant.name = json["name"].asString();
+    }
+    assistant.object = "assistant";
+    assistant.created_at = 0;  // Jan does not have this
+    if (json.isMember("tools")) {
+      assistant.tools = json["tools"];
+    }
+    if (json.isMember("model")) {
+      assistant.model = json["model"];
+    }
+    assistant.instructions = json["instructions"].asString();
+
+    return assistant;
+  }
+};
+
+struct Assistant {
+  /**
+   * The identifier, which can be referenced in API endpoints.
+   */
+  std::string id;
+
+  /**
+   * The object type, which is always assistant.
+   */
+  std::string object = "assistant";
+
+  /**
+   * The Unix timestamp (in seconds) for when the assistant was created.
+   */
+  uint64_t created_at;
+
+  /**
+   * The name of the assistant. The maximum length is 256 characters.
+   */
+  std::optional<std::string> name;
+
+  /**
+   * The description of the assistant. The maximum length is 512 characters.
+   */
+  std::optional<std::string> description;
+
+  /**
+   * ID of the model to use. You can use the List models API to see all of
+   * your available models, or see our Model overview for descriptions of them.
+   */
+  std::string model;
+
+  /**
+   * The system instructions that the assistant uses. The maximum length is
+   * 256,000 characters.
+   */
+  std::optional<std::string> instructions;
+
+  /**
+   * A list of tool enabled on the assistant. There can be a maximum of 128
+   * tools per assistant. Tools can be of types code_interpreter, file_search,
+   * or function.
+   */
+  std::vector<std::unique_ptr<AssistantTool>> tools;
+
+  /**
+   * A set of resources that are used by the assistant's tools. The resources
+   * are specific to the type of tool. For example, the code_interpreter tool
+   * requires a list of file IDs, while the file_search tool requires a list
+   * of vector store IDs.
+   */
+  std::optional<std::variant<ThreadCodeInterpreter, ThreadFileSearch>>
+      tool_resources;
+
+  /**
+   * Set of 16 key-value pairs that can be attached to an object. This can be
+   * useful for storing additional information about the object in a structured
+   * format. Keys can be a maximum of 64 characters long and values can be a
+   * maximum of 512 characters long.
+   */
+  Cortex::VariantMap metadata;
+
+  /**
+   * What sampling temperature to use, between 0 and 2. Higher values like
+   * 0.8 will make the output more random, while lower values like 0.2 will
+   * make it more focused and deterministic.
+   */
+  std::optional<float> temperature;
+
+  /**
+   * An alternative to sampling with temperature, called nucleus sampling,
+   * where the model considers the results of the tokens with top_p
+   * probability mass. So 0.1 means only the tokens comprising the top 10%
+   * probability mass are considered.
+   *
+   * We generally recommend altering this or temperature but not both.
+   */
+  std::optional<float> top_p;
+};
+}  // namespace OpenAi

engine/common/assistant_tool.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <string>
+
+namespace OpenAi {
+struct AssistantTool {
+  std::string type;
+
+  AssistantTool(const std::string& type) : type{type} {}
+
+  virtual ~AssistantTool() = default;
+};
+
+struct AssistantCodeInterpreterTool : public AssistantTool {
+  AssistantCodeInterpreterTool() : AssistantTool{"code_interpreter"} {}
+
+  ~AssistantCodeInterpreterTool() = default;
+};
+
+struct AssistantFileSearchTool : public AssistantTool {
+  AssistantFileSearchTool() : AssistantTool("file_search") {}
+
+  ~AssistantFileSearchTool() = default;
+
+  /**
+   * The ranking options for the file search. If not specified,
+   * the file search tool will use the auto ranker and a score_threshold of 0.
+   *
+   * See the file search tool documentation for more information.
+   */
+  struct RankingOption {
+    /**
+     * The ranker to use for the file search. If not specified will use the auto ranker.
+     */
+    std::string ranker;
+
+    /**
+     * The score threshold for the file search. All values must be a
+     * floating point number between 0 and 1.
+     */
+    float score_threshold;
+  };
+
+  /**
+   * Overrides for the file search tool.
+   */
+  struct FileSearch {
+    /**
+     * The maximum number of results the file search tool should output.
+     * The default is 20 for gpt-4* models and 5 for gpt-3.5-turbo.
+     * This number should be between 1 and 50 inclusive.
+     *
+     * Note that the file search tool may output fewer than max_num_results results.
+     * See the file search tool documentation for more information.
+     */
+    int max_num_result;
+  };
+};
+
+struct AssistantFunctionTool : public AssistantTool {
+  AssistantFunctionTool() : AssistantTool("function") {}
+
+  ~AssistantFunctionTool() = default;
+
+  struct Function {
+    /**
+     * A description of what the function does, used by the model to choose
+     * when and how to call the function.
+     */
+    std::string description;
+
+    /**
+     * The name of the function to be called. Must be a-z, A-Z, 0-9, or contain
+     * underscores and dashes, with a maximum length of 64.
+     */
+    std::string name;
+
+    // TODO: namh handle parameters
+
+    /**
+     * Whether to enable strict schema adherence when generating the function call.
+     * If set to true, the model will follow the exact schema defined in the parameters
+     * field. Only a subset of JSON Schema is supported when strict is true.
+     *
+     * Learn more about Structured Outputs in the function calling guide.
+     */
+    std::optional<bool> strict;
+  };
+};
+}  // namespace OpenAi

engine/config/model_config.h

@@ -1,18 +1,15 @@
 #pragma once
 
 #include <json/json.h>
-#include <cmath>
 #include <ctime>
 #include <fstream>
-#include <iomanip>
 #include <limits>
 #include <sstream>
 #include <stdexcept>
 #include <string>
 #include <vector>
 #include "utils/format_utils.h"
 #include "utils/remote_models_utils.h"
-#include "yaml-cpp/yaml.h"
 
 namespace config {
 

engine/controllers/assistants.cc

@@ -0,0 +1,74 @@
+#include "assistants.h"
+#include "utils/cortex_utils.h"
+#include "utils/logging_utils.h"
+
+void Assistants::RetrieveAssistant(
+    const HttpRequestPtr& req,
+    std::function<void(const HttpResponsePtr&)>&& callback,
+    const std::string& assistant_id) const {
+  CTL_INF("RetrieveAssistant: " + assistant_id);
+  auto res = assistant_service_->RetrieveAssistant(assistant_id);
+  if (res.has_error()) {
+    Json::Value ret;
+    ret["message"] = res.error();
+    auto resp = cortex_utils::CreateCortexHttpJsonResponse(ret);
+    resp->setStatusCode(k400BadRequest);
+    callback(resp);
+  } else {
+    auto to_json_res = res->ToJson();
+    if (to_json_res.has_error()) {
+      CTL_ERR("Failed to convert assistant to json: " + to_json_res.error());
+      Json::Value ret;
+      ret["message"] = to_json_res.error();
+      auto resp = cortex_utils::CreateCortexHttpJsonResponse(ret);
+      resp->setStatusCode(k400BadRequest);
+      callback(resp);
+    } else {
+      // TODO: namh need to use the text response because it contains model config
+      auto resp =
+          cortex_utils::CreateCortexHttpJsonResponse(res->ToJson().value());
+      resp->setStatusCode(k200OK);
+      callback(resp);
+    }
+  }
+}
+
+void Assistants::ModifyAssistant(
+    const HttpRequestPtr& req,
+    std::function<void(const HttpResponsePtr&)>&& callback,
+    const std::string& assistant_id) {
+  auto json_body = req->getJsonObject();
+  if (json_body == nullptr) {
+    Json::Value ret;
+    ret["message"] = "Request body can't be empty";
+    auto resp = cortex_utils::CreateCortexHttpJsonResponse(ret);
+    resp->setStatusCode(k400BadRequest);
+    callback(resp);
+    return;
+  }
+
+  // auto res =
+  //     assistant_service_->ModifyAssistant(thread_id, nullptr, metadata.value());
+  // if (res.has_error()) {
+  //   Json::Value ret;
+  //   ret["message"] = res.error();
+  //   auto resp = cortex_utils::CreateCortexHttpJsonResponse(ret);
+  //   resp->setStatusCode(k400BadRequest);
+  //   callback(resp);
+  // } else {
+  //   auto message_to_json = res->ToJson();
+  //   if (message_to_json.has_error()) {
+  //     CTL_ERR("Failed to convert message to json: " + message_to_json.error());
+  //     Json::Value ret;
+  //     ret["message"] = message_to_json.error();
+  //     auto resp = cortex_utils::CreateCortexHttpJsonResponse(ret);
+  //     resp->setStatusCode(k400BadRequest);
+  //     callback(resp);
+  //   } else {
+  //     auto resp =
+  //         cortex_utils::CreateCortexHttpJsonResponse(res->ToJson().value());
+  //     resp->setStatusCode(k200OK);
+  //     callback(resp);
+  //   }
+  // }
+}

engine/controllers/assistants.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <drogon/HttpController.h>
+#include <trantor/utils/Logger.h>
+#include "services/assistant_service.h"
+
+using namespace drogon;
+
+class Assistants : public drogon::HttpController<Assistants, false> {
+ public:
+  METHOD_LIST_BEGIN
+  ADD_METHOD_TO(Assistants::RetrieveAssistant, "/v1/assistants/{assistant_id}",
+                Get);
+  ADD_METHOD_TO(Assistants::ModifyAssistant, "/v1/assistants/{assistant_id}",
+                Options, Post, Patch);
+  METHOD_LIST_END
+
+  explicit Assistants(std::shared_ptr<AssistantService> assistant_srv)
+      : assistant_service_{assistant_srv} {};
+
+  void RetrieveAssistant(const HttpRequestPtr& req,
+                         std::function<void(const HttpResponsePtr&)>&& callback,
+                         const std::string& assistant_id) const;
+
+  void ModifyAssistant(const HttpRequestPtr& req,
+                       std::function<void(const HttpResponsePtr&)>&& callback,
+                       const std::string& assistant_id);
+
+ private:
+  std::shared_ptr<AssistantService> assistant_service_;
+};