Method finish_request

runners/proxy/ProxyRunner.cpp:1553–1592

}

void ProxyRunner::finish_request(const td::Bits256 &worker_request_id, const td::Bits256 &client_request_id,
                                 std::shared_ptr<ProxyClientInfo> client, TcpClient::ConnectionId client_connection_id,
                                 std::shared_ptr<ProxyWorkerInfo> worker,
                                 std::shared_ptr<ProxyWorkerConnectionInfo> worker_connection,
                                 ton::tl_object_ptr<cocoon_api::tokensUsed> tokens_used, td::int64 to_unlock,
                                 bool is_success, double work_time, double worker_run_time) {
  auto to_deduct = tokens_used->total_tokens_used_;
  worker->adjust_balance(to_deduct);
  client->deduct(to_deduct);
  client->release_reserve(to_unlock);
  if (is_success) {
    worker->forwarded_query_success(work_time);
    worker_connection->forwarded_query_success(work_time, worker_run_time);
    client->stop_query();
  } else {
    worker->forwarded_query_failed(work_time);
    worker_connection->forwarded_query_failed(work_time, worker_run_time);
    client->stop_query();
  }
  CHECK(running_queries_.erase(worker_request_id));

  stats_->total_adjusted_tokens_used += (double)tokens_used->total_tokens_used_;
  stats_->prompt_adjusted_tokens_used += (double)tokens_used->prompt_tokens_used_;
  stats_->cached_adjusted_tokens_used += (double)tokens_used->cached_tokens_used_;
  stats_->completion_adjusted_tokens_used += (double)tokens_used->completion_tokens_used_;
  stats_->reasoning_adjusted_tokens_used += (double)tokens_used->reasoning_tokens_used_;

  sign_worker_payment(*worker);
  //proxy.workerRequestPayment signed_payment:proxy.SignedPayment db_tokens:long max_tokens:long last_request_tokens:long last_request_client:string =
  //proxy.WorkerRequestPayment;
  auto req = cocoon::create_serialize_tl_object<cocoon_api::proxy_workerRequestPayment>(
      worker_request_id, worker->signed_payment(), worker->tokens_committed_to_db(), worker->tokens_max(), to_deduct,
      client->client_owner_address().rserialize(true));
  send_message_to_connection(worker_connection->connection_id, std::move(req));

  sign_client_payment(*client);
  auto req2 = cocoon::create_serialize_tl_object<cocoon_api::proxy_clientRequestPayment>(
      client_request_id, client->signed_payment(), client->tokens_committed_to_db(), client->tokens_max(), to_deduct);
  send_message_to_connection(client_connection_id, std::move(req2));
}

/*
 *