new fields in rpcInvokeReqExtra

common/tl-files/common.tl

@@ -42,6 +42,34 @@ pair {X:Type} {Y:Type} a:X b:Y = Pair X Y;
 
 true = True; // this can be used as void type and serialized to empty array in PHP
 
+exactlyOnce.uuid lo:long hi:long = exactlyOnce.Uuid;
+
+exactlyOnce.prepareRequest persistent_query_uuid:%exactlyOnce.Uuid = exactlyOnce.PersistentRequest;
+exactlyOnce.commitRequest persistent_query_uuid:%exactlyOnce.Uuid persistent_slot_uuid:%exactlyOnce.Uuid = exactlyOnce.PersistentRequest;
+
+tracing.traceID#2f4ac855 lo:long hi:long = tracing.TraceID;
+
+tracing.traceContext#c463a95c
+    fields_mask: #
+    trace_id: %(tracing.TraceID)
+    parent_id: fields_mask.2?long
+    source_id: fields_mask.3?string
+
+    // status = reserved_status_0 | (reserved_status_1 << 1)
+    // status == 0 - drop
+    // status == 1 - record
+    // status == 2 - defer
+    reserved_status_0: fields_mask.0?true
+    reserved_status_1: fields_mask.1?true
+
+    reserved_level_0: fields_mask.4?true
+    reserved_level_1: fields_mask.5?true
+    reserved_level_2: fields_mask.6?true
+
+    debug_flag: fields_mask.7?true
+
+   = tracing.TraceContext;
+
 stat#9d56e6b2 %(Dictionary string) = Stat;
 
 rpcInvokeReqExtra#f3ef81a9 {flags:#}
@@ -62,6 +90,9 @@ rpcInvokeReqExtra#f3ef81a9 {flags:#}
   supported_compression_version:flags.25?int // note, that client support compression, to possibly compress answers
   random_delay:flags.26?double // starting query would be delayed by random number, not grater than given
   return_view_number:flags.27?%True // Barsic related parameter: return view number in response
+  persistent_query: flags.28?exactlyOnce.PersistentRequest
+  trace_context:flags.29?%(tracing.TraceContext)
+  execution_context:flags.30?string // contains serialized execution context.
   = RpcInvokeReqExtra flags;
 
 rpcReqResultExtra#c5011709 {flags:#}

common/tl/constants/common.h

@@ -45,6 +45,17 @@ namespace vk {
 namespace tl {
 namespace common {
 
+namespace tracing::traceContext {
+static constexpr uint32_t return_reserved_status_0 = 1 << 0;
+static constexpr uint32_t return_reserved_status_1 = 1 << 1;
+static constexpr uint32_t parent_id = 1 << 2;
+static constexpr uint32_t source_id = 1 << 3;
+static constexpr uint32_t return_reserved_level_0 = 1 << 4;
+static constexpr uint32_t return_reserved_level_1 = 1 << 5;
+static constexpr uint32_t return_reserved_level_2 = 1 << 6;
+static constexpr uint32_t return_debug = 1 << 7;
+} // namespace tracing::traceContext
+
 namespace rpc_invoke_req_extra_flags {
 inline constexpr uint32_t return_binlog_pos = 1U << 0U;
 inline constexpr uint32_t return_binlog_time = 1U << 1U;
@@ -63,7 +74,9 @@ inline constexpr uint32_t supported_compression_version = 1U << 25U;
 inline constexpr uint32_t random_delay = 1U << 26U;
 inline constexpr uint32_t return_view_number = 1U << 27U;
 inline constexpr uint32_t persistent_query = 1U << 28U;
-inline constexpr uint32_t ALL = 0x1ebd00df;
+inline constexpr uint32_t trace_context = 1U << 29U;
+inline constexpr uint32_t execution_context = 1U << 30U;
+inline constexpr uint32_t ALL = 0x7ebd00df;
 } // namespace rpc_invoke_req_extra_flags
 
 namespace rpc_req_result_extra_flags {

common/tl/query-header.cpp

@@ -90,6 +90,24 @@ static int tl_fetch_query_flags(tl_query_header_t* header) {
       return -1;
     }
   }
+  if (flags & flag::persistent_query) {
+    header->persistent_query.fetch();
+    if (tl_fetch_error()) {
+      return -1;
+    }
+  }
+  if (flags & flag::trace_context) {
+    header->trace_context.fetch();
+    if (tl_fetch_error()) {
+      return -1;
+    }
+  }
+  if (flags & flag::execution_context) {
+    vk::tl::fetch_string(header->execution_context);
+    if (tl_fetch_error()) {
+      return -1;
+    }
+  }
   return 0;
 }
 
@@ -318,6 +336,15 @@ void tl_store_header(const tl_query_header_t* header) {
       if (flags & flag::random_delay) {
         tl_store_double(header->random_delay);
       }
+      if (flags & flag::persistent_query) {
+        header->persistent_query.store();
+      }
+      if (flags & flag::trace_context) {
+        header->trace_context.store();
+      }
+      if (flags & flag::execution_context) {
+        vk::tl::store_string(header->execution_context);
+      }
     } else if (header->actor_id) {
       tl_store_int(TL_RPC_DEST_ACTOR);
       tl_store_long(header->actor_id);

common/tl/query-header.h

@@ -9,6 +9,7 @@
 
 #include "common/pid.h"
 #include "common/tl/constants/common.h"
+#include "common/tl/tl-types.h"
 
 enum class result_header_type { result, error, wrapped_error };
 
@@ -29,6 +30,9 @@ struct tl_query_header_t {
   std::vector<std::string> string_forward_keys;
   int supported_compression_version{};
   double random_delay{};
+  exactlyOnce::PersistentRequest persistent_query{};
+  tracing::traceContext trace_context{};
+  std::string execution_context;
 };
 
 struct tl_query_answer_header_t {

common/tl/tl-types.h

@@ -0,0 +1,207 @@
+// Compiler for PHP (aka KPHP)
+// Copyright (c) 2026 LLC «V Kontakte»
+// Distributed under the GPL v3 License, see LICENSE.notice.txt
+
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <utility>
+#include <variant>
+
+#include "common/tl/constants/common.h"
+#include "common/tl/fetch.h"
+#include "common/tl/parse.h"
+#include "common/tl/store.h"
+
+namespace exactlyOnce {
+
+struct uuid final {
+  int64_t lo{};
+  int64_t hi{};
+
+  bool fetch() {
+    lo = tl_fetch_long();
+    if (tl_fetch_error()) {
+      return false;
+    }
+    hi = tl_fetch_long();
+    return !tl_fetch_error();
+  }
+
+  void store() const {
+    tl_store_long(lo);
+    tl_store_long(hi);
+  }
+};
+
+struct prepareRequest final {
+  exactlyOnce::uuid persistent_query_uuid{};
+
+  bool fetch() {
+    return persistent_query_uuid.fetch();
+  }
+
+  void store() const {
+    persistent_query_uuid.store();
+  }
+};
+
+struct commitRequest final {
+  exactlyOnce::uuid persistent_query_uuid{};
+  exactlyOnce::uuid persistent_slot_uuid{};
+
+  bool fetch() {
+    return persistent_query_uuid.fetch() && persistent_slot_uuid.fetch();
+  }
+
+  void store() const {
+    persistent_query_uuid.store();
+    persistent_slot_uuid.store();
+  }
+};
+
+class PersistentRequest final {
+  static constexpr int32_t PREPARE_REQUEST_MAGIC = 0xc8d7'1b66;
+  static constexpr int32_t COMMIT_REQUEST_MAGIC = 0x6836'b983;
+
+public:
+  std::variant<exactlyOnce::prepareRequest, exactlyOnce::commitRequest> request;
+
+  bool fetch() {
+    const int32_t magic{tl_fetch_int()};
+    if (tl_fetch_error()) {
+      return false;
+    }
+    if (exactlyOnce::prepareRequest prepare_request{}; magic == PREPARE_REQUEST_MAGIC && prepare_request.fetch()) {
+      request.emplace<exactlyOnce::prepareRequest>(prepare_request);
+      return true;
+    }
+    if (exactlyOnce::commitRequest commit_request{}; magic == COMMIT_REQUEST_MAGIC && commit_request.fetch()) {
+      request.emplace<exactlyOnce::commitRequest>(commit_request);
+      return true;
+    }
+    return false;
+  }
+
+  void store() const {
+    std::visit(
+        [](const auto& value) {
+          using value_t = std::decay_t<decltype(value)>;
+          if constexpr (std::is_same_v<value_t, exactlyOnce::prepareRequest>) {
+            tl_store_int(PREPARE_REQUEST_MAGIC);
+          } else if constexpr (std::is_same_v<value_t, exactlyOnce::commitRequest>) {
+            tl_store_int(COMMIT_REQUEST_MAGIC);
+          } else {
+            // condition is strange because of c++17 compiler. It is equivalent to `false`
+            static_assert(sizeof(value_t) && false, "exactlyOnce::PersistentRequest only supports prepareRequest and commitRequest");
+          }
+          value.store();
+        },
+        request);
+  }
+};
+} // namespace exactlyOnce
+
+namespace tracing {
+
+struct traceID final {
+  int64_t lo{};
+  int64_t hi{};
+
+  bool fetch() {
+    lo = tl_fetch_long();
+    if (tl_fetch_error()) {
+      return false;
+    }
+    hi = tl_fetch_long();
+    return !tl_fetch_error();
+  }
+
+  void store() const {
+    tl_store_long(lo);
+    tl_store_long(hi);
+  }
+};
+
+class traceContext final {
+  static constexpr uint32_t RETURN_RESERVED_STATUS_0_FLAG = vk::tl::common::tracing::traceContext::return_reserved_status_0;
+  static constexpr uint32_t RETURN_RESERVED_STATUS_1_FLAG = vk::tl::common::tracing::traceContext::return_reserved_status_1;
+  static constexpr uint32_t PARENT_ID_FLAG = vk::tl::common::tracing::traceContext::parent_id;
+  static constexpr uint32_t SOURCE_ID_FLAG = vk::tl::common::tracing::traceContext::source_id;
+  static constexpr uint32_t RETURN_RESERVED_LEVEL_0_FLAG = vk::tl::common::tracing::traceContext::return_reserved_level_0;
+  static constexpr uint32_t RETURN_RESERVED_LEVEL_1_FLAG = vk::tl::common::tracing::traceContext::return_reserved_level_1;
+  static constexpr uint32_t RETURN_RESERVED_LEVEL_2_FLAG = vk::tl::common::tracing::traceContext::return_reserved_level_2;
+  static constexpr uint32_t RETURN_DEBUG_FLAG = vk::tl::common::tracing::traceContext::return_debug;
+
+public:
+  tracing::traceID trace_id{};
+  std::optional<int64_t> opt_parent_id;
+  std::optional<std::string> opt_source_id;
+
+  // status = reserved_status_0 | (reserved_status_1 << 1)
+  // status == 0 - drop
+  // status == 1 - record
+  // status == 2 - defer
+  bool reserved_status_0{};
+  bool reserved_status_1{};
+
+  bool reserved_level_0{};
+  bool reserved_level_1{};
+  bool reserved_level_2{};
+
+  bool debug_flag{};
+
+  bool fetch() {
+    const int32_t fields_mask{tl_fetch_int()};
+    bool ok{!tl_fetch_error()};
+
+    ok = ok && trace_id.fetch();
+    if (ok && static_cast<bool>(fields_mask & PARENT_ID_FLAG)) {
+      opt_parent_id.emplace(tl_fetch_long());
+      ok = ok && !tl_fetch_error();
+    }
+    if (ok && static_cast<bool>(fields_mask & SOURCE_ID_FLAG)) {
+      std::string value;
+      vk::tl::fetch_string(value);
+      opt_source_id.emplace(std::move(value));
+      ok = ok && !tl_fetch_error();
+    }
+
+    reserved_status_0 = static_cast<bool>(fields_mask & RETURN_RESERVED_STATUS_0_FLAG);
+    reserved_status_1 = static_cast<bool>(fields_mask & RETURN_RESERVED_STATUS_1_FLAG);
+    reserved_level_0 = static_cast<bool>(fields_mask & RETURN_RESERVED_LEVEL_0_FLAG);
+    reserved_level_1 = static_cast<bool>(fields_mask & RETURN_RESERVED_LEVEL_1_FLAG);
+    reserved_level_2 = static_cast<bool>(fields_mask & RETURN_RESERVED_LEVEL_2_FLAG);
+    debug_flag = static_cast<bool>(fields_mask & RETURN_DEBUG_FLAG);
+
+    return ok;
+  }
+
+  void store() const {
+    tl_store_int(get_flags());
+    trace_id.store();
+    if (opt_parent_id) {
+      tl_store_long(opt_parent_id.value());
+    }
+    if (opt_source_id) {
+      vk::tl::store_string(opt_source_id.value());
+    }
+  }
+
+  uint32_t get_flags() const noexcept {
+    uint32_t flags{};
+    flags |= static_cast<uint32_t>(reserved_status_0);
+    flags |= static_cast<uint32_t>(reserved_status_1) << 1;
+    flags |= static_cast<uint32_t>(reserved_level_0) << 4;
+    flags |= static_cast<uint32_t>(reserved_level_1) << 5;
+    flags |= static_cast<uint32_t>(reserved_level_2) << 6;
+    flags |= static_cast<uint32_t>(debug_flag) << 7;
+
+    flags |= static_cast<uint32_t>(opt_parent_id.has_value()) << 2;
+    flags |= static_cast<uint32_t>(opt_source_id.has_value()) << 3;
+    return flags;
+  }
+};
+} // namespace tracing