GenAITypes.h File

Shared public vocabulary for NEAT GenAI APIs. More...

Included Headers

#include "pipeline/Tensor.h" #include <nlohmann/json.hpp> #include <cstddef> #include <cstdint> #include <exception> #include <filesystem> #include <functional> #include <initializer_list> #include <iterator> #include <memory> #include <optional> #include <string> #include <vector>

Namespaces Index

namespace	simaai
namespace	neat
namespace	genai

Classes Index

class	ImageList
	Ordered image inputs for GenAI requests and chat messages. More...
struct	ChatMessage
struct	GenerationMetrics
struct	GenerationRequest
struct	GenerationResult
struct	TokenSample
class	GenerationStream
class	iterator
class	Producer

Description

Shared public vocabulary for NEAT GenAI APIs.

File Listing

The file content with the documentation metadata removed is:

1

5#pragma once

6

7#include "pipeline/Tensor.h"

8

9#include <nlohmann/json.hpp>

10

11#include <cstddef>

12#include <cstdint>

13#include <exception>

14#include <filesystem>

15#include <functional>

16#include <initializer_list>

17#include <iterator>

18#include <memory>

19#include <optional>

20#include <string>

21#include <vector>

22

23#if defined(SIMA_WITH_OPENCV)

24#include <opencv2/core/mat.hpp>

25#endif

26

27namespace simaai::neat::genai {

28

29using Json = nlohmann::ordered_json;

30

31class ASRModel;

32class GenAIModel;

33class OpenAIServer;

34class VisionLanguageModel;

35

42enum class GenAITask {

43 VisionLanguage,

44 ASR,

45};

46

55class ImageList {

56public:

57 ImageList() = default;

58 ImageList(std::initializer_list<Tensor> images);

59 explicit ImageList(std::vector<Tensor> images);

60

61 ImageList& operator=(std::initializer_list<Tensor> images);

62 ImageList& operator=(std::vector<Tensor> images);

63

64#if defined(SIMA_WITH_OPENCV)

65 ImageList(std::initializer_list<cv::Mat> images);

66 explicit ImageList(const std::vector<cv::Mat>& images);

67

68 ImageList& operator=(std::initializer_list<cv::Mat> images);

69 ImageList& operator=(const std::vector<cv::Mat>& images);

70#endif

71

72 bool empty() const;

73 std::size_t size() const;

74 const std::vector<Tensor>& tensors() const;

75 std::vector<Tensor>& tensors();

76

77private:

78 std::vector<Tensor> images_;

79};

80

81struct ChatMessage {

82 std::string role;

83 std::string content;

84 ImageList images;

85 bool use_cached_images = false;

86 Json tool_calls = Json::array();

87 std::optional<std::string> tool_call_id;

88 std::optional<std::string> name;

89};

90

91struct GenerationMetrics {

92 std::uint32_t generated_tokens = 0;

93 double time_to_first_token_s = 0.0;

94 double tokens_per_second = 0.0;

95};

96

97struct GenerationRequest {

98 std::optional<std::string> prompt;

99 std::optional<std::string> system_prompt;

100 std::vector<ChatMessage> messages;

101 ImageList images;

102 bool use_cached_images = false;

103 std::optional<Tensor> audio;

104 std::optional<std::filesystem::path> audio_file;

105 std::string language = "en";

106 std::uint32_t max_new_tokens = 0;

107 Json tools = Json::array();

108 Json tool_choice = nullptr;

109};

110

111struct GenerationResult {

112 std::string text;

113 GenerationMetrics metrics;

114 std::string finish_reason;

115 Json tool_calls = Json::array();

116};

117

118struct TokenSample {

119 std::string text;

120 GenerationMetrics metrics;

121 bool is_final = false;

122 std::string finish_reason;

123 Json tool_calls = Json::array();

124};

125

126class GenerationStream {

127public:

128 class iterator {

129 public:

130 using iterator_category = std::input_iterator_tag;

131 using value_type = TokenSample;

132 using difference_type = std::ptrdiff_t;

133 using pointer = const TokenSample*;

134 using reference = const TokenSample&;

135

136 iterator() = default;

137

138 reference operator*() const;

139 pointer operator->() const;

140 iterator& operator++();

141 void operator++(int);

142

143 friend bool operator==(const iterator& lhs, const iterator& rhs);

144 friend bool operator!=(const iterator& lhs, const iterator& rhs) {

145 return !(lhs == rhs);

146 }

147

148 private:

149 explicit iterator(GenerationStream* stream);

150 void advance();

151

152 GenerationStream* stream_ = nullptr;

153 std::optional<TokenSample> current_;

154

155 friend class GenerationStream;

156 };

157

158 ~GenerationStream();

159

160 GenerationStream(GenerationStream&&) noexcept;

161 GenerationStream& operator=(GenerationStream&&) noexcept;

162

163 GenerationStream(const GenerationStream&) = delete;

164 GenerationStream& operator=(const GenerationStream&) = delete;

165

166 std::optional<TokenSample> next();

167 void cancel();

168 iterator begin();

169 iterator end();

170

171private:

172 struct Impl;

173 class Producer {

174 public:

175 void record_metric(const std::string& metric, double value);

176 void record_text(const std::string& text, bool stream_end);

177 void push(TokenSample sample);

178 void finish(std::string finish_reason, std::optional<std::uint32_t> generated_tokens);

179 bool cancelled() const;

180 GenerationMetrics current_metrics() const;

181

182 private:

183 explicit Producer(Impl& impl);

184

185 Impl& impl_;

186

187 friend struct Impl;

188 };

189 using ProducerFn = std::function<void(Producer&)>;

190 using CancelFn = std::function<void()>;

191

192 explicit GenerationStream(std::unique_ptr<Impl> impl);

193 GenerationStream(ProducerFn producer, CancelFn cancel);

194

195 std::unique_ptr<Impl> impl_;

196

197 friend class ASRModel;

198 friend class VisionLanguageModel;

199};

200

201} // namespace simaai::neat::genai

---

Generated via doxygen2docusaurus 2.0.0 by Doxygen 1.9.1.