diff --git a/source/extensions/filters/network/generic_proxy/BUILD b/source/extensions/filters/network/generic_proxy/BUILD
index c4759e9bf8f25..7a81689cea4b2 100644
--- a/source/extensions/filters/network/generic_proxy/BUILD
+++ b/source/extensions/filters/network/generic_proxy/BUILD
@@ -23,11 +23,13 @@ envoy_cc_library(
         ":route_lib",
         ":stats_lib",
         ":tracing_lib",
+        "//envoy/access_log:access_log_interface",
         "//envoy/network:filter_interface",
         "//envoy/server:factory_context_interface",
         "//envoy/stats:timespan_interface",
         "//source/common/common:linked_object",
         "//source/common/common:minimal_logger_lib",
+        "//source/common/formatter:substitution_formatter_lib",
         "//source/common/stats:timespan_lib",
         "//source/common/stream_info:stream_info_lib",
         "//source/common/tracing:tracer_config_lib",
@@ -146,20 +148,6 @@ envoy_cc_library(
     ],
 )
 
-envoy_cc_library(
-    name = "file_access_log_lib",
-    hdrs = [
-        "file_access_log.h",
-    ],
-    deps = [
-        "//envoy/access_log:access_log_config_interface",
-        "//envoy/access_log:access_log_interface",
-        "//source/common/common:utility_lib",
-        "//source/common/formatter:substitution_format_string_lib",
-        "@envoy_api//envoy/extensions/access_loggers/file/v3:pkg_cc_proto",
-    ],
-)
-
 envoy_cc_library(
     name = "access_log_lib",
     srcs = [
@@ -169,8 +157,12 @@ envoy_cc_library(
         "access_log.h",
     ],
     deps = [
-        ":file_access_log_lib",
+        "//envoy/access_log:access_log_config_interface",
+        "//envoy/formatter:substitution_formatter_interface",
+        "//source/common/config:utility_lib",
         "//source/extensions/filters/network/generic_proxy/interface:stream_interface",
+        "@envoy_api//envoy/extensions/access_loggers/file/v3:pkg_cc_proto",
+        "@envoy_api//envoy/extensions/filters/network/generic_proxy/v3:pkg_cc_proto",
     ],
     # Ensure this factory in the source is always linked in.
     alwayslink = 1,
@@ -231,6 +223,7 @@ envoy_cc_library(
     ],
     deps = [
         ":route_interface",
+        "//envoy/access_log:access_log_config_interface",
         "//envoy/tracing:trace_config_interface",
         "//envoy/tracing:tracer_interface",
         "//source/extensions/filters/network/generic_proxy:access_log_lib",
diff --git a/source/extensions/filters/network/generic_proxy/access_log.cc b/source/extensions/filters/network/generic_proxy/access_log.cc
index a96df953494d8..b946f30275620 100644
--- a/source/extensions/filters/network/generic_proxy/access_log.cc
+++ b/source/extensions/filters/network/generic_proxy/access_log.cc
@@ -1,7 +1,10 @@
 #include "source/extensions/filters/network/generic_proxy/access_log.h"
 
+#include "envoy/extensions/filters/network/generic_proxy/v3/generic_proxy.pb.h"
 #include "envoy/registry/registry.h"
 
+#include "source/common/config/utility.h"
+
 namespace Envoy {
 namespace Extensions {
 namespace NetworkFilters {
@@ -29,26 +32,20 @@ ProtobufWkt::Value StringValueFormatterProvider::formatValueWithContext(
 absl::optional<std::string>
 GenericStatusCodeFormatterProvider::formatWithContext(const FormatterContext& context,
                                                       const StreamInfo::StreamInfo&) const {
-  if (context.response_ == nullptr) {
-    return absl::nullopt;
-  }
-
-  const int code = context.response_->status().code();
+  CHECK_DATA_OR_RETURN(context, response_, absl::nullopt);
+  const int code = checked_data->response_->status().code();
   return std::to_string(code);
 }
 
 ProtobufWkt::Value
 GenericStatusCodeFormatterProvider::formatValueWithContext(const FormatterContext& context,
                                                            const StreamInfo::StreamInfo&) const {
-  if (context.response_ == nullptr) {
-    return ValueUtil::nullValue();
-  }
-
-  const int code = context.response_->status().code();
+  CHECK_DATA_OR_RETURN(context, response_, ValueUtil::nullValue());
+  const int code = checked_data->response_->status().code();
   return ValueUtil::numberValue(code);
 }
 
-class SimpleCommandParser : public CommandParser {
+class GenericProxyCommandParser : public Formatter::CommandParser {
 public:
   using ProviderFunc =
       std::function<FormatterProviderPtr(absl::string_view, absl::optional<size_t> max_length)>;
@@ -75,10 +72,8 @@ class SimpleCommandParser : public CommandParser {
                return std::make_unique<StringValueFormatterProvider>(
                    [](const FormatterContext& context,
                       const StreamInfo::StreamInfo&) -> absl::optional<std::string> {
-                     if (context.request_) {
-                       return std::string(context.request_->method());
-                     }
-                     return absl::nullopt;
+                     CHECK_DATA_OR_RETURN(context, request_, absl::nullopt);
+                     return std::string(checked_data->request_->method());
                    });
              }},
             {"HOST",
@@ -86,10 +81,8 @@ class SimpleCommandParser : public CommandParser {
                return std::make_unique<StringValueFormatterProvider>(
                    [](const FormatterContext& context,
                       const StreamInfo::StreamInfo&) -> absl::optional<std::string> {
-                     if (context.request_) {
-                       return std::string(context.request_->host());
-                     }
-                     return absl::nullopt;
+                     CHECK_DATA_OR_RETURN(context, request_, absl::nullopt);
+                     return std::string(checked_data->request_->host());
                    });
              }},
             {"PATH",
@@ -97,10 +90,8 @@ class SimpleCommandParser : public CommandParser {
                return std::make_unique<StringValueFormatterProvider>(
                    [](const FormatterContext& context,
                       const StreamInfo::StreamInfo&) -> absl::optional<std::string> {
-                     if (context.request_) {
-                       return std::string(context.request_->path());
-                     }
-                     return absl::nullopt;
+                     CHECK_DATA_OR_RETURN(context, request_, absl::nullopt);
+                     return std::string(checked_data->request_->path());
                    });
              }},
             {"PROTOCOL",
@@ -108,10 +99,8 @@ class SimpleCommandParser : public CommandParser {
                return std::make_unique<StringValueFormatterProvider>(
                    [](const FormatterContext& context,
                       const StreamInfo::StreamInfo&) -> absl::optional<std::string> {
-                     if (context.request_) {
-                       return std::string(context.request_->protocol());
-                     }
-                     return absl::nullopt;
+                     CHECK_DATA_OR_RETURN(context, request_, absl::nullopt);
+                     return std::string(checked_data->request_->protocol());
                    });
              }},
             {"REQUEST_PROPERTY",
@@ -120,10 +109,9 @@ class SimpleCommandParser : public CommandParser {
                    [key = std::string(command_arg)](
                        const FormatterContext& context,
                        const StreamInfo::StreamInfo&) -> absl::optional<std::string> {
-                     if (!context.request_) {
-                       return absl::nullopt;
-                     }
-                     auto optional_view = context.request_->get(key);
+                     CHECK_DATA_OR_RETURN(context, request_, absl::nullopt);
+
+                     auto optional_view = checked_data->request_->get(key);
                      if (!optional_view.has_value()) {
                        return absl::nullopt;
                      }
@@ -136,10 +124,8 @@ class SimpleCommandParser : public CommandParser {
                    [key = std::string(command_arg)](
                        const FormatterContext& context,
                        const StreamInfo::StreamInfo&) -> absl::optional<std::string> {
-                     if (!context.response_) {
-                       return absl::nullopt;
-                     }
-                     auto optional_view = context.response_->get(key);
+                     CHECK_DATA_OR_RETURN(context, response_, absl::nullopt);
+                     auto optional_view = checked_data->response_->get(key);
                      if (!optional_view.has_value()) {
                        return absl::nullopt;
                      }
@@ -154,18 +140,9 @@ class SimpleCommandParser : public CommandParser {
   }
 };
 
-class DefaultBuiltInCommandParserFactory : public BuiltInCommandParserFactory {
-public:
-  std::string name() const override { return "envoy.built_in_formatters.generic_poxy.default"; }
-
-  // BuiltInCommandParserFactory
-  CommandParserPtr createCommandParser() const override {
-    return std::make_unique<SimpleCommandParser>();
-  }
-};
-
-REGISTER_FACTORY(DefaultBuiltInCommandParserFactory, BuiltInCommandParserFactory);
-REGISTER_FACTORY(FileAccessLogFactory, AccessLogInstanceFactory);
+Formatter::CommandParserPtr createGenericProxyCommandParser() {
+  return std::make_unique<GenericProxyCommandParser>();
+}
 
 } // namespace GenericProxy
 } // namespace NetworkFilters
diff --git a/source/extensions/filters/network/generic_proxy/access_log.h b/source/extensions/filters/network/generic_proxy/access_log.h
index 99c69fc567f65..9ebb528789109 100644
--- a/source/extensions/filters/network/generic_proxy/access_log.h
+++ b/source/extensions/filters/network/generic_proxy/access_log.h
@@ -1,6 +1,9 @@
 #pragma once
 
-#include "source/extensions/filters/network/generic_proxy/file_access_log.h"
+#include "envoy/access_log/access_log_config.h"
+#include "envoy/extensions/access_loggers/file/v3/file.pb.h"
+#include "envoy/formatter/substitution_formatter.h"
+
 #include "source/extensions/filters/network/generic_proxy/interface/stream.h"
 
 namespace Envoy {
@@ -8,34 +11,24 @@ namespace Extensions {
 namespace NetworkFilters {
 namespace GenericProxy {
 
-struct FormatterContext {
+struct FormatterContextExtension : public Formatter::Context::Extension {
+  FormatterContextExtension(const RequestHeaderFrame* request, const ResponseHeaderFrame* response)
+      : request_(request), response_(response) {}
+  FormatterContextExtension() = default;
+
   const RequestHeaderFrame* request_{};
   const ResponseHeaderFrame* response_{};
-
-  static constexpr absl::string_view category() { return "generic_proxy"; }
 };
 
-// Formatter for generic proxy.
-using Formatter = Formatter::FormatterBase<FormatterContext>;
-using FormatterProvider = Envoy::Formatter::FormatterProviderBase<FormatterContext>;
-using FormatterProviderPtr = std::unique_ptr<FormatterProvider>;
-using CommandParser = Envoy::Formatter::CommandParserBase<FormatterContext>;
-using CommandParserPtr = Envoy::Formatter::CommandParserBasePtr<FormatterContext>;
-using CommandParserFactory = Envoy::Formatter::CommandParserFactoryBase<FormatterContext>;
-using BuiltInCommandParserFactory =
-    Envoy::Formatter::BuiltInCommandParserFactoryBase<FormatterContext>;
+#define CHECK_DATA_OR_RETURN(context, field, return_value)                                         \
+  const auto checked_data = context.typedExtension<FormatterContextExtension>();                   \
+  if (!checked_data.has_value() || checked_data->field == nullptr) {                               \
+    return return_value;                                                                           \
+  }
 
-// Access log for generic proxy.
-using AccessLogFilter = AccessLog::FilterBase<FormatterContext>;
-using AccessLogFilterPtr = std::unique_ptr<AccessLogFilter>;
-using AccessLogFilterFactory = AccessLog::ExtensionFilterFactoryBase<FormatterContext>;
-using AccessLogInstance = AccessLog::InstanceBase<FormatterContext>;
-using AccessLogInstanceSharedPtr = std::shared_ptr<AccessLogInstance>;
-using AccessLogInstanceFactory = AccessLog::AccessLogInstanceFactoryBase<FormatterContext>;
-
-// File access log for generic proxy.
-using FileAccessLog = FileAccessLogBase<FormatterContext>;
-using FileAccessLogFactory = FileAccessLogFactoryBase<FormatterContext>;
+using FormatterProvider = Formatter::FormatterProvider;
+using FormatterProviderPtr = std::unique_ptr<FormatterProvider>;
+using FormatterContext = Formatter::Context;
 
 class StringValueFormatterProvider : public FormatterProvider {
 public:
@@ -69,6 +62,8 @@ class GenericStatusCodeFormatterProvider : public FormatterProvider {
                                             const StreamInfo::StreamInfo&) const override;
 };
 
+Formatter::CommandParserPtr createGenericProxyCommandParser();
+
 } // namespace GenericProxy
 } // namespace NetworkFilters
 } // namespace Extensions
diff --git a/source/extensions/filters/network/generic_proxy/config.cc b/source/extensions/filters/network/generic_proxy/config.cc
index 5daaf4fab5975..a922cb83dbaa3 100644
--- a/source/extensions/filters/network/generic_proxy/config.cc
+++ b/source/extensions/filters/network/generic_proxy/config.cc
@@ -2,48 +2,15 @@
 
 #include "source/common/access_log/access_log_impl.h"
 #include "source/common/tracing/tracer_manager_impl.h"
+#include "source/extensions/filters/network/generic_proxy/access_log.h"
 #include "source/extensions/filters/network/generic_proxy/rds.h"
 #include "source/extensions/filters/network/generic_proxy/rds_impl.h"
 
-#include "access_log.h"
-
 namespace Envoy {
 namespace Extensions {
 namespace NetworkFilters {
 namespace GenericProxy {
 
-template <class Context>
-static AccessLog::FilterBasePtr<Context>
-accessLogFilterFromProto(const envoy::config::accesslog::v3::AccessLogFilter& config,
-                         Server::Configuration::FactoryContext& context) {
-  if (!config.has_extension_filter()) {
-    ExceptionUtil::throwEnvoyException(
-        "Access log filter: only extension filter is supported by non-HTTP access loggers.");
-  }
-
-  auto& factory =
-      Config::Utility::getAndCheckFactory<Envoy::AccessLog::ExtensionFilterFactoryBase<Context>>(
-          config.extension_filter());
-  return factory.createFilter(config.extension_filter(), context);
-}
-
-template <class Context>
-static AccessLog::InstanceBaseSharedPtr<Context>
-accessLoggerFromProto(const envoy::config::accesslog::v3::AccessLog& config,
-                      Server::Configuration::FactoryContext& context) {
-  AccessLog::FilterBasePtr<Context> filter;
-  if (config.has_filter()) {
-    filter = accessLogFilterFromProto<Context>(config.filter(), context);
-  }
-
-  auto& factory =
-      Config::Utility::getAndCheckFactory<Envoy::AccessLog::AccessLogInstanceFactoryBase<Context>>(
-          config);
-  ProtobufTypes::MessagePtr message = Config::Utility::translateToFactoryConfig(
-      config, context.messageValidationVisitor(), factory);
-
-  return factory.createAccessLogInstance(*message, std::move(filter), context);
-}
 SINGLETON_MANAGER_REGISTRATION(generic_route_config_provider_manager);
 SINGLETON_MANAGER_REGISTRATION(generic_proxy_code_or_flag_stats);
 
@@ -156,10 +123,12 @@ Factory::createFilterFactoryFromProtoTyped(const ProxyConfig& proto_config,
   }
 
   // Access log configuration.
-  std::vector<AccessLogInstanceSharedPtr> access_logs;
+  std::vector<AccessLog::InstanceSharedPtr> access_logs;
   for (const auto& access_log : proto_config.access_log()) {
-    AccessLogInstanceSharedPtr current_access_log =
-        accessLoggerFromProto<FormatterContext>(access_log, context);
+    std::vector<Formatter::CommandParserPtr> command_parsers;
+    command_parsers.push_back(createGenericProxyCommandParser());
+    AccessLog::InstanceSharedPtr current_access_log =
+        AccessLog::AccessLogFactory::fromProto(access_log, context, std::move(command_parsers));
     access_logs.push_back(current_access_log);
   }
 
diff --git a/source/extensions/filters/network/generic_proxy/file_access_log.h b/source/extensions/filters/network/generic_proxy/file_access_log.h
deleted file mode 100644
index 4110fc9e793af..0000000000000
--- a/source/extensions/filters/network/generic_proxy/file_access_log.h
+++ /dev/null
@@ -1,123 +0,0 @@
-#pragma once
-
-#include "envoy/access_log/access_log.h"
-#include "envoy/access_log/access_log_config.h"
-#include "envoy/extensions/access_loggers/file/v3/file.pb.h"
-#include "envoy/extensions/access_loggers/file/v3/file.pb.validate.h"
-
-#include "source/common/common/utility.h"
-#include "source/common/formatter/substitution_format_string.h"
-
-namespace Envoy {
-namespace Extensions {
-namespace NetworkFilters {
-namespace GenericProxy {
-
-template <class Context> class FileAccessLogBase : public AccessLog::InstanceBase<Context> {
-public:
-  FileAccessLogBase(const Filesystem::FilePathAndType& access_log_file_info,
-                    AccessLog::FilterBasePtr<Context>&& filter,
-                    Formatter::FormatterBasePtr<Context>&& formatter,
-                    AccessLog::AccessLogManager& log_manager)
-      : filter_(std::move(filter)), formatter_(std::move(formatter)) {
-    log_file_ = log_manager.createAccessLog(access_log_file_info).value();
-  }
-
-  void log(const Context& context, const StreamInfo::StreamInfo& stream_info) override {
-    if (filter_ != nullptr && !filter_->evaluate(context, stream_info)) {
-      return;
-    }
-    log_file_->write(formatter_->formatWithContext(context, stream_info));
-  }
-
-private:
-  AccessLog::AccessLogFileSharedPtr log_file_;
-  AccessLog::FilterBasePtr<Context> filter_;
-  Formatter::FormatterBasePtr<Context> formatter_;
-};
-
-template <class Context>
-class FileAccessLogFactoryBase : public AccessLog::AccessLogInstanceFactoryBase<Context> {
-public:
-  FileAccessLogFactoryBase()
-      : name_(fmt::format("envoy.{}.access_loggers.file", Context::category())) {}
-
-  AccessLog::InstanceBaseSharedPtr<Context> createAccessLogInstance(
-      const Protobuf::Message& config, AccessLog::FilterBasePtr<Context>&& filter,
-      Server::Configuration::FactoryContext& context,
-      std::vector<Formatter::CommandParserBasePtr<Context>>&& command_parsers = {}) override {
-    const auto& typed_config = MessageUtil::downcastAndValidate<
-        const envoy::extensions::access_loggers::file::v3::FileAccessLog&>(
-        config, context.messageValidationVisitor());
-
-    Formatter::FormatterBasePtr<Context> formatter;
-
-    switch (typed_config.access_log_format_case()) {
-    case envoy::extensions::access_loggers::file::v3::FileAccessLog::AccessLogFormatCase::kFormat:
-      if (typed_config.format().empty()) {
-        formatter = getDefaultFormatter();
-      } else {
-        envoy::config::core::v3::SubstitutionFormatString sff_config;
-        sff_config.mutable_text_format_source()->set_inline_string(typed_config.format());
-        formatter = THROW_OR_RETURN_VALUE(
-            Formatter::SubstitutionFormatStringUtils::fromProtoConfig<Context>(
-                sff_config, context, std::move(command_parsers)),
-            Formatter::FormatterBasePtr<Context>);
-      }
-      break;
-    case envoy::extensions::access_loggers::file::v3::FileAccessLog::AccessLogFormatCase::
-        kJsonFormat:
-      formatter = Formatter::SubstitutionFormatStringUtils::createJsonFormatter<Context>(
-          typed_config.json_format(), false, false, false, command_parsers);
-      break;
-    case envoy::extensions::access_loggers::file::v3::FileAccessLog::AccessLogFormatCase::
-        kTypedJsonFormat: {
-      envoy::config::core::v3::SubstitutionFormatString sff_config;
-      *sff_config.mutable_json_format() = typed_config.typed_json_format();
-      formatter =
-          THROW_OR_RETURN_VALUE(Formatter::SubstitutionFormatStringUtils::fromProtoConfig<Context>(
-                                    sff_config, context, std::move(command_parsers)),
-                                Formatter::FormatterBasePtr<Context>);
-      break;
-    }
-    case envoy::extensions::access_loggers::file::v3::FileAccessLog::AccessLogFormatCase::
-        kLogFormat:
-      formatter =
-          THROW_OR_RETURN_VALUE(Formatter::SubstitutionFormatStringUtils::fromProtoConfig<Context>(
-                                    typed_config.log_format(), context, std::move(command_parsers)),
-                                Formatter::FormatterBasePtr<Context>);
-      break;
-    case envoy::extensions::access_loggers::file::v3::FileAccessLog::AccessLogFormatCase::
-        ACCESS_LOG_FORMAT_NOT_SET:
-      formatter = getDefaultFormatter();
-      break;
-    }
-    if (formatter == nullptr) {
-      ExceptionUtil::throwEnvoyException(
-          "Access log: no format and no default format for file access log");
-    }
-
-    Filesystem::FilePathAndType file_info{Filesystem::DestinationType::File, typed_config.path()};
-    return std::make_shared<FileAccessLogBase<Context>>(
-        file_info, std::move(filter), std::move(formatter),
-        context.serverFactoryContext().accessLogManager());
-  }
-
-  ProtobufTypes::MessagePtr createEmptyConfigProto() override {
-    return ProtobufTypes::MessagePtr{
-        new envoy::extensions::access_loggers::file::v3::FileAccessLog()};
-  }
-
-  std::string name() const override { return name_; }
-
-protected:
-  virtual Formatter::FormatterBasePtr<Context> getDefaultFormatter() const { return nullptr; }
-
-private:
-  const std::string name_;
-};
-
-} // namespace GenericProxy
-} // namespace NetworkFilters
-} // namespace Extensions
-} // namespace Envoy
diff --git a/source/extensions/filters/network/generic_proxy/proxy.cc b/source/extensions/filters/network/generic_proxy/proxy.cc
index fad6c85444dbc..9edccec994006 100644
--- a/source/extensions/filters/network/generic_proxy/proxy.cc
+++ b/source/extensions/filters/network/generic_proxy/proxy.cc
@@ -6,6 +6,7 @@
 #include "envoy/network/connection.h"
 
 #include "source/common/config/utility.h"
+#include "source/common/formatter/substitution_formatter.h"
 #include "source/common/protobuf/protobuf.h"
 #include "source/common/stream_info/stream_info_impl.h"
 #include "source/extensions/filters/network/generic_proxy/interface/filter.h"
@@ -625,8 +626,10 @@ void ActiveStream::completeStream(absl::optional<DownstreamStreamResetReason> re
   }
 
   for (const auto& access_log : parent_.config_->accessLogs()) {
-    const FormatterContext context{request_header_frame_.get(), response_header_frame_.get()};
-    access_log->log(context, stream_info_);
+    const FormatterContextExtension context_extension(request_header_frame_.get(),
+                                                      response_header_frame_.get());
+    Formatter::Context context;
+    access_log->log(context.setExtension(context_extension), stream_info_);
   }
 
   // TODO(wbpcode): use ranges to simplify the code.
diff --git a/source/extensions/filters/network/generic_proxy/proxy.h b/source/extensions/filters/network/generic_proxy/proxy.h
index 27c1f63b9d587..4a80b98aa30ac 100644
--- a/source/extensions/filters/network/generic_proxy/proxy.h
+++ b/source/extensions/filters/network/generic_proxy/proxy.h
@@ -4,6 +4,7 @@
 #include <memory>
 #include <string>
 
+#include "envoy/access_log/access_log.h"
 #include "envoy/config/core/v3/extension.pb.h"
 #include "envoy/extensions/filters/network/generic_proxy/v3/generic_proxy.pb.h"
 #include "envoy/extensions/filters/network/generic_proxy/v3/generic_proxy.pb.validate.h"
@@ -63,7 +64,7 @@ class FilterConfigImpl : public FilterConfig {
                    Rds::RouteConfigProviderSharedPtr route_config_provider,
                    std::vector<NamedFilterFactoryCb> factories, Tracing::TracerSharedPtr tracer,
                    Tracing::ConnectionManagerTracingConfigPtr tracing_config,
-                   std::vector<AccessLogInstanceSharedPtr>&& access_logs,
+                   AccessLog::InstanceSharedPtrVector&& access_logs,
                    const CodeOrFlags& code_or_flags,
                    Envoy::Server::Configuration::FactoryContext& context)
       : stat_prefix_(stat_prefix),
@@ -89,9 +90,7 @@ class FilterConfigImpl : public FilterConfig {
   }
   GenericFilterStats& stats() override { return stats_; }
   const CodeOrFlags& codeOrFlags() const override { return code_or_flags_; }
-  const std::vector<AccessLogInstanceSharedPtr>& accessLogs() const override {
-    return access_logs_;
-  }
+  const AccessLog::InstanceSharedPtrVector& accessLogs() const override { return access_logs_; }
 
   // FilterChainFactory
   void createFilterChain(FilterChainManager& manager) override {
@@ -118,7 +117,7 @@ class FilterConfigImpl : public FilterConfig {
 
   Tracing::TracerSharedPtr tracer_;
   Tracing::ConnectionManagerTracingConfigPtr tracing_config_;
-  std::vector<AccessLogInstanceSharedPtr> access_logs_;
+  std::vector<AccessLog::InstanceSharedPtr> access_logs_;
 
   TimeSource& time_source_;
 };
diff --git a/source/extensions/filters/network/generic_proxy/proxy_config.h b/source/extensions/filters/network/generic_proxy/proxy_config.h
index a91a35068dd67..5b754c9bfec69 100644
--- a/source/extensions/filters/network/generic_proxy/proxy_config.h
+++ b/source/extensions/filters/network/generic_proxy/proxy_config.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "envoy/access_log/access_log_config.h"
 #include "envoy/tracing/trace_config.h"
 #include "envoy/tracing/tracer.h"
 
@@ -62,7 +63,7 @@ class FilterConfig : public FilterChainFactory {
   /**
    * @return const std::vector<AccessLogInstanceSharedPtr>& access logs.
    */
-  virtual const std::vector<AccessLogInstanceSharedPtr>& accessLogs() const PURE;
+  virtual const AccessLog::InstanceSharedPtrVector& accessLogs() const PURE;
 };
 
 } // namespace GenericProxy
diff --git a/test/extensions/filters/network/generic_proxy/BUILD b/test/extensions/filters/network/generic_proxy/BUILD
index ac070b2c8b372..1d1a360ea3671 100644
--- a/test/extensions/filters/network/generic_proxy/BUILD
+++ b/test/extensions/filters/network/generic_proxy/BUILD
@@ -49,8 +49,11 @@ envoy_cc_test(
     rbe_pool = "6gig",
     deps = [
         ":fake_codec_lib",
+        "//source/common/access_log:access_log_lib",
         "//source/common/buffer:buffer_lib",
         "//source/common/formatter:formatter_extension_lib",
+        "//source/common/formatter:substitution_format_string_lib",
+        "//source/extensions/access_loggers/file:config",
         "//source/extensions/filters/network/generic_proxy:proxy_lib",
         "//test/extensions/filters/network/generic_proxy/mocks:codec_mocks",
         "//test/extensions/filters/network/generic_proxy/mocks:filter_mocks",
@@ -70,6 +73,7 @@ envoy_cc_test(
     deps = [
         ":fake_codec_lib",
         "//source/common/buffer:buffer_lib",
+        "//source/extensions/access_loggers/file:config",
         "//source/extensions/filters/network/generic_proxy:config",
         "//source/extensions/filters/network/generic_proxy/router:config",
         "//source/extensions/tracers/zipkin:config",
@@ -140,6 +144,7 @@ envoy_cc_test(
     rbe_pool = "6gig",
     deps = [
         ":fake_codec_lib",
+        "//source/common/formatter:substitution_formatter_lib",
         "//source/extensions/filters/network/generic_proxy:access_log_lib",
         "//test/mocks/stream_info:stream_info_mocks",
     ],
diff --git a/test/extensions/filters/network/generic_proxy/access_log_test.cc b/test/extensions/filters/network/generic_proxy/access_log_test.cc
index 04426bdb0667a..1c694cdb448d1 100644
--- a/test/extensions/filters/network/generic_proxy/access_log_test.cc
+++ b/test/extensions/filters/network/generic_proxy/access_log_test.cc
@@ -1,3 +1,4 @@
+#include "source/common/formatter/substitution_formatter.h"
 #include "source/extensions/filters/network/generic_proxy/access_log.h"
 
 #include "test/extensions/filters/network/generic_proxy/fake_codec.h"
@@ -12,165 +13,203 @@ namespace GenericProxy {
 namespace {
 
 TEST(GenericStatusCodeFormatterProviderTest, GenericStatusCodeFormatterProviderTest) {
-  FormatterContext context;
+  FormatterContextExtension context;
   GenericStatusCodeFormatterProvider formatter;
   StreamInfo::MockStreamInfo stream_info;
 
-  EXPECT_EQ(formatter.formatWithContext(context, stream_info), absl::nullopt);
-  EXPECT_TRUE(formatter.formatValueWithContext(context, stream_info).has_null_value());
+  EXPECT_EQ(formatter.formatWithContext(Formatter::Context().setExtension(context), stream_info),
+            absl::nullopt);
+  EXPECT_TRUE(
+      formatter.formatValueWithContext(Formatter::Context().setExtension(context), stream_info)
+          .has_null_value());
 
   FakeStreamCodecFactory::FakeResponse response;
   response.status_ = {1234, false};
   context.response_ = &response;
 
-  EXPECT_EQ(formatter.formatWithContext(context, stream_info).value(), "1234");
-  EXPECT_EQ(formatter.formatValueWithContext(context, stream_info).number_value(), 1234.0);
+  EXPECT_EQ(
+      formatter.formatWithContext(Formatter::Context().setExtension(context), stream_info).value(),
+      "1234");
+  EXPECT_EQ(
+      formatter.formatValueWithContext(Formatter::Context().setExtension(context), stream_info)
+          .number_value(),
+      1234.0);
 }
 
 TEST(StringValueFormatterProviderTest, StringValueFormatterProviderTest) {
   {
 
-    FormatterContext context;
+    FormatterContextExtension context;
     StringValueFormatterProvider formatter(
-        [](const FormatterContext& context,
+        [](const Formatter::Context& context,
            const StreamInfo::StreamInfo&) -> absl::optional<std::string> {
-          if (context.request_ == nullptr) {
-            return absl::nullopt;
-          }
-          return std::string(context.request_->path());
+          CHECK_DATA_OR_RETURN(context, request_, absl::nullopt);
+          return std::string(checked_data->request_->path());
         },
         9);
     StreamInfo::MockStreamInfo stream_info;
 
-    EXPECT_EQ(formatter.formatWithContext(context, stream_info), absl::nullopt);
-    EXPECT_TRUE(formatter.formatValueWithContext(context, stream_info).has_null_value());
+    EXPECT_EQ(formatter.formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              absl::nullopt);
+    EXPECT_TRUE(
+        formatter.formatValueWithContext(Formatter::Context().setExtension(context), stream_info)
+            .has_null_value());
 
     FakeStreamCodecFactory::FakeRequest request;
     request.path_ = "ANYTHING";
     context.request_ = &request;
 
-    EXPECT_EQ(formatter.formatWithContext(context, stream_info).value(), "ANYTHING");
-    EXPECT_EQ(formatter.formatValueWithContext(context, stream_info).string_value(), "ANYTHING");
+    EXPECT_EQ(formatter.formatWithContext(Formatter::Context().setExtension(context), stream_info)
+                  .value(),
+              "ANYTHING");
+    EXPECT_EQ(
+        formatter.formatValueWithContext(Formatter::Context().setExtension(context), stream_info)
+            .string_value(),
+        "ANYTHING");
 
     request.path_ = "ANYTHING_LONGER_THAN_9";
-    EXPECT_EQ(formatter.formatWithContext(context, stream_info).value(), "ANYTHING_");
-    EXPECT_EQ(formatter.formatValueWithContext(context, stream_info).string_value(), "ANYTHING_");
+    EXPECT_EQ(formatter.formatWithContext(Formatter::Context().setExtension(context), stream_info)
+                  .value(),
+              "ANYTHING_");
+    EXPECT_EQ(
+        formatter.formatValueWithContext(Formatter::Context().setExtension(context), stream_info)
+            .string_value(),
+        "ANYTHING_");
   }
 }
 
 TEST(AccessLogFormatterTest, AccessLogFormatterTest) {
 
+  std::vector<Formatter::CommandParserPtr> commands;
+  commands.push_back(createGenericProxyCommandParser());
+
   {
     // Test for %METHOD%.
-    FormatterContext context;
-    auto formatter = *Envoy::Formatter::FormatterBaseImpl<FormatterContext>::create("%METHOD%");
+    FormatterContextExtension context;
+    auto formatter = *Envoy::Formatter::FormatterImpl::create("%METHOD%", false, commands);
     StreamInfo::MockStreamInfo stream_info;
 
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "-");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "-");
 
     FakeStreamCodecFactory::FakeRequest request;
     request.method_ = "FAKE_METHOD";
     context.request_ = &request;
 
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "FAKE_METHOD");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "FAKE_METHOD");
   }
 
   {
     // Test for %HOST%.
-    FormatterContext context;
-    auto formatter = *Envoy::Formatter::FormatterBaseImpl<FormatterContext>::create("%HOST%");
+    FormatterContextExtension context;
+    auto formatter = *Envoy::Formatter::FormatterImpl::create("%HOST%", false, commands);
     StreamInfo::MockStreamInfo stream_info;
 
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "-");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "-");
 
     FakeStreamCodecFactory::FakeRequest request;
     request.host_ = "FAKE_HOST";
     context.request_ = &request;
 
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "FAKE_HOST");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "FAKE_HOST");
   }
 
   {
     // Test for %PATH%.
-    FormatterContext context;
-    auto formatter = *Envoy::Formatter::FormatterBaseImpl<FormatterContext>::create("%PATH%");
+    FormatterContextExtension context;
+    auto formatter = *Envoy::Formatter::FormatterImpl::create("%PATH%", false, commands);
     StreamInfo::MockStreamInfo stream_info;
 
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "-");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "-");
 
     FakeStreamCodecFactory::FakeRequest request;
     request.path_ = "FAKE_PATH";
     context.request_ = &request;
 
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "FAKE_PATH");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "FAKE_PATH");
   }
 
   {
     // Test for %PROTOCOL%.
-    FormatterContext context;
-    auto formatter = *Envoy::Formatter::FormatterBaseImpl<FormatterContext>::create("%PROTOCOL%");
+    FormatterContextExtension context;
+    auto formatter = *Envoy::Formatter::FormatterImpl::create("%PROTOCOL%", false, commands);
     StreamInfo::MockStreamInfo stream_info;
 
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "-");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "-");
 
     FakeStreamCodecFactory::FakeRequest request;
     request.protocol_ = "FAKE_PROTOCOL";
     context.request_ = &request;
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "FAKE_PROTOCOL");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "FAKE_PROTOCOL");
   }
 
   {
     // Test for %REQUEST_PROPERTY%.
-    FormatterContext context;
-    auto formatter = *Envoy::Formatter::FormatterBaseImpl<FormatterContext>::create(
-        "%REQUEST_PROPERTY(FAKE_KEY)%");
+    FormatterContextExtension context;
+    auto formatter =
+        *Envoy::Formatter::FormatterImpl::create("%REQUEST_PROPERTY(FAKE_KEY)%", false, commands);
     StreamInfo::MockStreamInfo stream_info;
 
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "-");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "-");
 
     FakeStreamCodecFactory::FakeRequest request;
 
     context.request_ = &request;
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "-");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "-");
 
     request.data_["FAKE_KEY"] = "FAKE_VALUE";
 
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "FAKE_VALUE");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "FAKE_VALUE");
   }
 
   {
     // Test for %RESPONSE_PROPERTY%.
-    FormatterContext context;
-    auto formatter = *Envoy::Formatter::FormatterBaseImpl<FormatterContext>::create(
-        "%RESPONSE_PROPERTY(FAKE_KEY)%");
+    FormatterContextExtension context;
+    auto formatter =
+        *Envoy::Formatter::FormatterImpl::create("%RESPONSE_PROPERTY(FAKE_KEY)%", false, commands);
     StreamInfo::MockStreamInfo stream_info;
 
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "-");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "-");
 
     FakeStreamCodecFactory::FakeResponse response;
 
     context.response_ = &response;
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "-");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "-");
 
     response.data_["FAKE_KEY"] = "FAKE_VALUE";
 
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "FAKE_VALUE");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "FAKE_VALUE");
   }
 
   {
     // Test for %GENERIC_RESPONSE_CODE%.
-    FormatterContext context;
+    FormatterContextExtension context;
     auto formatter =
-        *Envoy::Formatter::FormatterBaseImpl<FormatterContext>::create("%GENERIC_RESPONSE_CODE%");
+        *Envoy::Formatter::FormatterImpl::create("%GENERIC_RESPONSE_CODE%", false, commands);
     StreamInfo::MockStreamInfo stream_info;
 
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "-");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "-");
 
     FakeStreamCodecFactory::FakeResponse response;
     response.status_ = {-1234, false};
     context.response_ = &response;
 
-    EXPECT_EQ(formatter->formatWithContext(context, stream_info), "-1234");
+    EXPECT_EQ(formatter->formatWithContext(Formatter::Context().setExtension(context), stream_info),
+              "-1234");
   }
 }
 
diff --git a/test/extensions/filters/network/generic_proxy/config_test.cc b/test/extensions/filters/network/generic_proxy/config_test.cc
index 7197e810c3542..d21737c819798 100644
--- a/test/extensions/filters/network/generic_proxy/config_test.cc
+++ b/test/extensions/filters/network/generic_proxy/config_test.cc
@@ -496,10 +496,11 @@ TEST(BasicFilterConfigTest, TestConfigurationWithAccessLogAndLogFilter1) {
   EXPECT_CALL(codec_factory_config, createCodecFactory(_, _))
       .WillOnce(Return(testing::ByMove(std::move(mock_codec_factory))));
 
-  EXPECT_THROW_WITH_MESSAGE(
-      { auto status_or = factory.createFilterFactoryFromProto(config, factory_context); },
-      EnvoyException,
-      "Access log filter: only extension filter is supported by non-HTTP access loggers.");
+  Network::FilterFactoryCb cb =
+      factory.createFilterFactoryFromProto(config, factory_context).value();
+  EXPECT_NE(nullptr, cb);
+  NiceMock<Network::MockFilterManager> filter_manager;
+  cb(filter_manager);
 }
 
 TEST(BasicFilterConfigTest, TestConfigurationWithAccessLogAndLogFilter2) {
@@ -539,7 +540,7 @@ TEST(BasicFilterConfigTest, TestConfigurationWithAccessLogAndLogFilter2) {
   Registry::InjectFactory<CodecFactoryConfig> registration(codec_factory_config);
 
   FakeAccessLogExtensionFilterFactory fake_access_log_extension_filter_factory;
-  Registry::InjectFactory<AccessLogFilterFactory> registration_log(
+  Registry::InjectFactory<AccessLog::ExtensionFilterFactory> registration_log(
       fake_access_log_extension_filter_factory);
 
   NiceMock<Server::Configuration::MockFactoryContext> factory_context;
diff --git a/test/extensions/filters/network/generic_proxy/fake_codec.h b/test/extensions/filters/network/generic_proxy/fake_codec.h
index 3c0b25bf9d3b6..1f9cd32f56378 100644
--- a/test/extensions/filters/network/generic_proxy/fake_codec.h
+++ b/test/extensions/filters/network/generic_proxy/fake_codec.h
@@ -2,6 +2,8 @@
 
 #include <cstdint>
 
+#include "envoy/access_log/access_log_config.h"
+
 #include "source/common/buffer/buffer_impl.h"
 #include "source/extensions/filters/network/generic_proxy/access_log.h"
 #include "source/extensions/filters/network/generic_proxy/interface/codec.h"
@@ -421,17 +423,17 @@ class FakeStreamCodecFactoryConfig : public CodecFactoryConfig {
   std::string name() const override { return "envoy.generic_proxy.codecs.fake"; }
 };
 
-class FakeAccessLogExtensionFilter : public AccessLogFilter {
-  bool evaluate(const FormatterContext&, const StreamInfo::StreamInfo&) const override {
+class FakeAccessLogExtensionFilter : public AccessLog::Filter {
+  bool evaluate(const Formatter::Context&, const StreamInfo::StreamInfo&) const override {
     return true;
   }
 };
 
-class FakeAccessLogExtensionFilterFactory : public AccessLogFilterFactory {
+class FakeAccessLogExtensionFilterFactory : public AccessLog::ExtensionFilterFactory {
 public:
   // AccessLogFilterFactory
-  AccessLogFilterPtr createFilter(const envoy::config::accesslog::v3::ExtensionFilter&,
-                                  Server::Configuration::FactoryContext&) override {
+  AccessLog::FilterPtr createFilter(const envoy::config::accesslog::v3::ExtensionFilter&,
+                                    Server::Configuration::FactoryContext&) override {
     return std::make_unique<FakeAccessLogExtensionFilter>();
   }
 
diff --git a/test/extensions/filters/network/generic_proxy/proxy_test.cc b/test/extensions/filters/network/generic_proxy/proxy_test.cc
index 31900ba301418..f9addf64e52ae 100644
--- a/test/extensions/filters/network/generic_proxy/proxy_test.cc
+++ b/test/extensions/filters/network/generic_proxy/proxy_test.cc
@@ -2,7 +2,10 @@
 #include <string>
 #include <utility>
 
+#include "source/common/access_log/access_log_impl.h"
+#include "source/common/formatter/substitution_format_string.h"
 #include "source/common/tracing/tracer_manager_impl.h"
+#include "source/extensions/access_loggers/common/file_access_log_impl.h"
 #include "source/extensions/filters/network/generic_proxy/proxy.h"
 
 #include "test/extensions/filters/network/generic_proxy/fake_codec.h"
@@ -45,7 +48,7 @@ class MockRouteConfigProvider : public Rds::RouteConfigProvider {
 
 class FilterConfigTest : public testing::Test {
 public:
-  void initializeFilterConfig(bool with_tracing = false, AccessLogInstanceSharedPtr logger = {},
+  void initializeFilterConfig(bool with_tracing = false, AccessLog::InstanceSharedPtr logger = {},
                               bool allow_no_decoder_filter = false) {
     if (with_tracing) {
       tracer_ = std::make_shared<NiceMock<Tracing::MockTracer>>();
@@ -93,7 +96,7 @@ class FilterConfigTest : public testing::Test {
 
     mock_route_entry_ = std::make_shared<NiceMock<MockRouteEntry>>();
 
-    std::vector<AccessLogInstanceSharedPtr> access_logs;
+    std::vector<AccessLog::InstanceSharedPtr> access_logs;
     if (logger) {
       access_logs.push_back(logger);
     }
@@ -104,16 +107,18 @@ class FilterConfigTest : public testing::Test {
         factory_context_);
   }
 
-  AccessLogInstanceSharedPtr loggerFormFormat(const std::string& format = DEFAULT_LOG_FORMAT) {
-    envoy::config::core::v3::SubstitutionFormatString sff_config;
-    sff_config.mutable_text_format_source()->set_inline_string(format);
-    auto formatter =
-        *Envoy::Formatter::SubstitutionFormatStringUtils::fromProtoConfig<FormatterContext>(
-            sff_config, factory_context_);
-
-    return std::make_shared<FileAccessLog>(
-        Filesystem::FilePathAndType{}, nullptr, std::move(formatter),
-        factory_context_.server_factory_context_.accessLogManager());
+  AccessLog::InstanceSharedPtr loggerFormFormat(const std::string& format = DEFAULT_LOG_FORMAT) {
+    envoy::extensions::access_loggers::file::v3::FileAccessLog file_log_config;
+    file_log_config.mutable_log_format()->mutable_text_format_source()->set_inline_string(format);
+    file_log_config.set_path("/fake/log/path");
+    envoy::config::accesslog::v3::AccessLog config;
+    config.mutable_typed_config()->PackFrom(file_log_config);
+    config.set_name("file");
+
+    std::vector<Formatter::CommandParserPtr> command_parsers;
+    command_parsers.push_back(createGenericProxyCommandParser());
+    return AccessLog::AccessLogFactory::fromProto(config, factory_context_,
+                                                  std::move(command_parsers));
   }
 
   NiceMock<Server::Configuration::MockFactoryContext> factory_context_;
@@ -189,7 +194,7 @@ TEST_F(FilterConfigTest, CodecFactory) {
 
 class FilterTest : public FilterConfigTest {
 public:
-  void initializeFilter(bool with_tracing = false, AccessLogInstanceSharedPtr logger = {},
+  void initializeFilter(bool with_tracing = false, AccessLog::InstanceSharedPtr logger = {},
                         bool allow_no_decoder_filter = false) {
     FilterConfigTest::initializeFilterConfig(with_tracing, logger, allow_no_decoder_filter);
 
diff --git a/tools/base/requirements.txt b/tools/base/requirements.txt
index 5b0faf771eeb8..8c954dc7ae273 100644
--- a/tools/base/requirements.txt
+++ b/tools/base/requirements.txt
@@ -95,88 +95,88 @@ aiohappyeyeballs==2.4.0 \
     --hash=sha256:55a1714f084e63d49639800f95716da97a1f173d46a16dfcfda0016abb93b6b2 \
     --hash=sha256:7ce92076e249169a13c2f49320d1967425eaf1f407522d707d59cac7628d62bd
     # via aiohttp
-aiohttp==3.11.12 \
-    --hash=sha256:0450ada317a65383b7cce9576096150fdb97396dcfe559109b403c7242faffef \
-    --hash=sha256:0b5263dcede17b6b0c41ef0c3ccce847d82a7da98709e75cf7efde3e9e3b5cae \
-    --hash=sha256:0d5176f310a7fe6f65608213cc74f4228e4f4ce9fd10bcb2bb6da8fc66991462 \
-    --hash=sha256:0ed49efcd0dc1611378beadbd97beb5d9ca8fe48579fc04a6ed0844072261b6a \
-    --hash=sha256:145a73850926018ec1681e734cedcf2716d6a8697d90da11284043b745c286d5 \
-    --hash=sha256:1987770fb4887560363b0e1a9b75aa303e447433c41284d3af2840a2f226d6e0 \
-    --hash=sha256:246067ba0cf5560cf42e775069c5d80a8989d14a7ded21af529a4e10e3e0f0e6 \
-    --hash=sha256:2c311e2f63e42c1bf86361d11e2c4a59f25d9e7aabdbdf53dc38b885c5435cdb \
-    --hash=sha256:2cee3b117a8d13ab98b38d5b6bdcd040cfb4181068d05ce0c474ec9db5f3c5bb \
-    --hash=sha256:2de1378f72def7dfb5dbd73d86c19eda0ea7b0a6873910cc37d57e80f10d64e1 \
-    --hash=sha256:30f546358dfa0953db92ba620101fefc81574f87b2346556b90b5f3ef16e55ce \
-    --hash=sha256:34245498eeb9ae54c687a07ad7f160053911b5745e186afe2d0c0f2898a1ab8a \
-    --hash=sha256:392432a2dde22b86f70dd4a0e9671a349446c93965f261dbaecfaf28813e5c42 \
-    --hash=sha256:3c0600bcc1adfaaac321422d615939ef300df81e165f6522ad096b73439c0f58 \
-    --hash=sha256:4016e383f91f2814e48ed61e6bda7d24c4d7f2402c75dd28f7e1027ae44ea204 \
-    --hash=sha256:40cd36749a1035c34ba8d8aaf221b91ca3d111532e5ccb5fa8c3703ab1b967ed \
-    --hash=sha256:413ad794dccb19453e2b97c2375f2ca3cdf34dc50d18cc2693bd5aed7d16f4b9 \
-    --hash=sha256:4a93d28ed4b4b39e6f46fd240896c29b686b75e39cc6992692e3922ff6982b4c \
-    --hash=sha256:4ee84c2a22a809c4f868153b178fe59e71423e1f3d6a8cd416134bb231fbf6d3 \
-    --hash=sha256:50c5c7b8aa5443304c55c262c5693b108c35a3b61ef961f1e782dd52a2f559c7 \
-    --hash=sha256:525410e0790aab036492eeea913858989c4cb070ff373ec3bc322d700bdf47c1 \
-    --hash=sha256:526c900397f3bbc2db9cb360ce9c35134c908961cdd0ac25b1ae6ffcaa2507ff \
-    --hash=sha256:54775858c7f2f214476773ce785a19ee81d1294a6bedc5cc17225355aab74802 \
-    --hash=sha256:584096938a001378484aa4ee54e05dc79c7b9dd933e271c744a97b3b6f644957 \
-    --hash=sha256:6130459189e61baac5a88c10019b21e1f0c6d00ebc770e9ce269475650ff7f73 \
-    --hash=sha256:67453e603cea8e85ed566b2700efa1f6916aefbc0c9fcb2e86aaffc08ec38e78 \
-    --hash=sha256:68d54234c8d76d8ef74744f9f9fc6324f1508129e23da8883771cdbb5818cbef \
-    --hash=sha256:6dfe7f984f28a8ae94ff3a7953cd9678550dbd2a1f9bda5dd9c5ae627744c78e \
-    --hash=sha256:74bd573dde27e58c760d9ca8615c41a57e719bff315c9adb6f2a4281a28e8798 \
-    --hash=sha256:7603ca26d75b1b86160ce1bbe2787a0b706e592af5b2504e12caa88a217767b0 \
-    --hash=sha256:76719dd521c20a58a6c256d058547b3a9595d1d885b830013366e27011ffe804 \
-    --hash=sha256:7c3623053b85b4296cd3925eeb725e386644fd5bc67250b3bb08b0f144803e7b \
-    --hash=sha256:7e44eba534381dd2687be50cbd5f2daded21575242ecfdaf86bbeecbc38dae8e \
-    --hash=sha256:7fe3d65279bfbee8de0fb4f8c17fc4e893eed2dba21b2f680e930cc2b09075c5 \
-    --hash=sha256:8340def6737118f5429a5df4e88f440746b791f8f1c4ce4ad8a595f42c980bd5 \
-    --hash=sha256:84ede78acde96ca57f6cf8ccb8a13fbaf569f6011b9a52f870c662d4dc8cd854 \
-    --hash=sha256:850ff6155371fd802a280f8d369d4e15d69434651b844bde566ce97ee2277420 \
-    --hash=sha256:87a2e00bf17da098d90d4145375f1d985a81605267e7f9377ff94e55c5d769eb \
-    --hash=sha256:88d385b8e7f3a870146bf5ea31786ef7463e99eb59e31db56e2315535d811f55 \
-    --hash=sha256:8a2fb742ef378284a50766e985804bd6adb5adb5aa781100b09befdbfa757b65 \
-    --hash=sha256:8dc0fba9a74b471c45ca1a3cb6e6913ebfae416678d90529d188886278e7f3f6 \
-    --hash=sha256:8fa1510b96c08aaad49303ab11f8803787c99222288f310a62f493faf883ede1 \
-    --hash=sha256:8fd12d0f989c6099e7b0f30dc6e0d1e05499f3337461f0b2b0dadea6c64b89df \
-    --hash=sha256:9060addfa4ff753b09392efe41e6af06ea5dd257829199747b9f15bfad819460 \
-    --hash=sha256:930ffa1925393381e1e0a9b82137fa7b34c92a019b521cf9f41263976666a0d6 \
-    --hash=sha256:936d8a4f0f7081327014742cd51d320296b56aa6d324461a13724ab05f4b2933 \
-    --hash=sha256:97fe431f2ed646a3b56142fc81d238abcbaff08548d6912acb0b19a0cadc146b \
-    --hash=sha256:9bd8695be2c80b665ae3f05cb584093a1e59c35ecb7d794d1edd96e8cc9201d7 \
-    --hash=sha256:9dec0000d2d8621d8015c293e24589d46fa218637d820894cb7356c77eca3259 \
-    --hash=sha256:a478aa11b328983c4444dacb947d4513cb371cd323f3845e53caeda6be5589d5 \
-    --hash=sha256:a481a574af914b6e84624412666cbfbe531a05667ca197804ecc19c97b8ab1b0 \
-    --hash=sha256:a4ac6a0f0f6402854adca4e3259a623f5c82ec3f0c049374133bcb243132baf9 \
-    --hash=sha256:a5e69046f83c0d3cb8f0d5bd9b8838271b1bc898e01562a04398e160953e8eb9 \
-    --hash=sha256:a7442662afebbf7b4c6d28cb7aab9e9ce3a5df055fc4116cc7228192ad6cb484 \
-    --hash=sha256:aa8a8caca81c0a3e765f19c6953416c58e2f4cc1b84829af01dd1c771bb2f91f \
-    --hash=sha256:ab3247d58b393bda5b1c8f31c9edece7162fc13265334217785518dd770792b8 \
-    --hash=sha256:b10a47e5390c4b30a0d58ee12581003be52eedd506862ab7f97da7a66805befb \
-    --hash=sha256:b34508f1cd928ce915ed09682d11307ba4b37d0708d1f28e5774c07a7674cac9 \
-    --hash=sha256:b8d3bb96c147b39c02d3db086899679f31958c5d81c494ef0fc9ef5bb1359b3d \
-    --hash=sha256:b9d45dbb3aaec05cf01525ee1a7ac72de46a8c425cb75c003acd29f76b1ffe94 \
-    --hash=sha256:bf4480a5438f80e0f1539e15a7eb8b5f97a26fe087e9828e2c0ec2be119a9f72 \
-    --hash=sha256:c160a04283c8c6f55b5bf6d4cad59bb9c5b9c9cd08903841b25f1f7109ef1259 \
-    --hash=sha256:c96a43822f1f9f69cc5c3706af33239489a6294be486a0447fb71380070d4d5f \
-    --hash=sha256:c9fd9dcf9c91affe71654ef77426f5cf8489305e1c66ed4816f5a21874b094b9 \
-    --hash=sha256:cddb31f8474695cd61fc9455c644fc1606c164b93bff2490390d90464b4655df \
-    --hash=sha256:ce1bb21fc7d753b5f8a5d5a4bae99566386b15e716ebdb410154c16c91494d7f \
-    --hash=sha256:d1c031a7572f62f66f1257db37ddab4cb98bfaf9b9434a3b4840bf3560f5e788 \
-    --hash=sha256:d589264dbba3b16e8951b6f145d1e6b883094075283dafcab4cdd564a9e353a0 \
-    --hash=sha256:dc065a4285307607df3f3686363e7f8bdd0d8ab35f12226362a847731516e42c \
-    --hash=sha256:e10c440d142fa8b32cfdb194caf60ceeceb3e49807072e0dc3a8887ea80e8c16 \
-    --hash=sha256:e3552fe98e90fdf5918c04769f338a87fa4f00f3b28830ea9b78b1bdc6140e0d \
-    --hash=sha256:e392804a38353900c3fd8b7cacbea5132888f7129f8e241915e90b85f00e3250 \
-    --hash=sha256:e4cecdb52aaa9994fbed6b81d4568427b6002f0a91c322697a4bfcc2b2363f5a \
-    --hash=sha256:e5148ca8955affdfeb864aca158ecae11030e952b25b3ae15d4e2b5ba299bad2 \
-    --hash=sha256:e6b2732ef3bafc759f653a98881b5b9cdef0716d98f013d376ee8dfd7285abf1 \
-    --hash=sha256:ea756b5a7bac046d202a9a3889b9a92219f885481d78cd318db85b15cc0b7bcf \
-    --hash=sha256:edb69b9589324bdc40961cdf0657815df674f1743a8d5ad9ab56a99e4833cfdd \
-    --hash=sha256:f0203433121484b32646a5f5ea93ae86f3d9559d7243f07e8c0eab5ff8e3f70e \
-    --hash=sha256:f6a19bcab7fbd8f8649d6595624856635159a6527861b9cdc3447af288a00c00 \
-    --hash=sha256:f752e80606b132140883bb262a457c475d219d7163d996dc9072434ffb0784c4 \
-    --hash=sha256:f7914ab70d2ee8ab91c13e5402122edbc77821c66d2758abb53aabe87f013287
+aiohttp==3.11.13 \
+    --hash=sha256:00c8ac69e259c60976aa2edae3f13d9991cf079aaa4d3cd5a49168ae3748dee3 \
+    --hash=sha256:01816f07c9cc9d80f858615b1365f8319d6a5fd079cd668cc58e15aafbc76a54 \
+    --hash=sha256:02876bf2f69b062584965507b07bc06903c2dc93c57a554b64e012d636952654 \
+    --hash=sha256:0e9eb7e5764abcb49f0e2bd8f5731849b8728efbf26d0cac8e81384c95acec3f \
+    --hash=sha256:0f6b2c5b4a4d22b8fb2c92ac98e0747f5f195e8e9448bfb7404cd77e7bfa243f \
+    --hash=sha256:1982c98ac62c132d2b773d50e2fcc941eb0b8bad3ec078ce7e7877c4d5a2dce7 \
+    --hash=sha256:1e83fb1991e9d8982b3b36aea1e7ad27ea0ce18c14d054c7a404d68b0319eebb \
+    --hash=sha256:25de43bb3cf83ad83efc8295af7310219af6dbe4c543c2e74988d8e9c8a2a917 \
+    --hash=sha256:28a772757c9067e2aee8a6b2b425d0efaa628c264d6416d283694c3d86da7689 \
+    --hash=sha256:2a4a13dfbb23977a51853b419141cd0a9b9573ab8d3a1455c6e63561387b52ff \
+    --hash=sha256:2a8a6bc19818ac3e5596310ace5aa50d918e1ebdcc204dc96e2f4d505d51740c \
+    --hash=sha256:2eabb269dc3852537d57589b36d7f7362e57d1ece308842ef44d9830d2dc3c90 \
+    --hash=sha256:35cda4e07f5e058a723436c4d2b7ba2124ab4e0aa49e6325aed5896507a8a42e \
+    --hash=sha256:42d689a5c0a0c357018993e471893e939f555e302313d5c61dfc566c2cad6185 \
+    --hash=sha256:4586a68730bd2f2b04a83e83f79d271d8ed13763f64b75920f18a3a677b9a7f0 \
+    --hash=sha256:47dc018b1b220c48089b5b9382fbab94db35bef2fa192995be22cbad3c5730c8 \
+    --hash=sha256:507ab05d90586dacb4f26a001c3abf912eb719d05635cbfad930bdbeb469b36c \
+    --hash=sha256:5194143927e494616e335d074e77a5dac7cd353a04755330c9adc984ac5a628e \
+    --hash=sha256:51c3ff9c7a25f3cad5c09d9aacbc5aefb9267167c4652c1eb737989b554fe278 \
+    --hash=sha256:55789e93c5ed71832e7fac868167276beadf9877b85697020c46e9a75471f55f \
+    --hash=sha256:5724cc77f4e648362ebbb49bdecb9e2b86d9b172c68a295263fa072e679ee69d \
+    --hash=sha256:5ad8f1c19fe277eeb8bc45741c6d60ddd11d705c12a4d8ee17546acff98e0802 \
+    --hash=sha256:5ceb81a4db2decdfa087381b5fc5847aa448244f973e5da232610304e199e7b2 \
+    --hash=sha256:64815c6f02e8506b10113ddbc6b196f58dbef135751cc7c32136df27b736db09 \
+    --hash=sha256:66047eacbc73e6fe2462b77ce39fc170ab51235caf331e735eae91c95e6a11e4 \
+    --hash=sha256:669dd33f028e54fe4c96576f406ebb242ba534dd3a981ce009961bf49960f117 \
+    --hash=sha256:684eea71ab6e8ade86b9021bb62af4bf0881f6be4e926b6b5455de74e420783a \
+    --hash=sha256:6b35aab22419ba45f8fc290d0010898de7a6ad131e468ffa3922b1b0b24e9d2e \
+    --hash=sha256:7104d5b3943c6351d1ad7027d90bdd0ea002903e9f610735ac99df3b81f102ee \
+    --hash=sha256:718d5deb678bc4b9d575bfe83a59270861417da071ab44542d0fcb6faa686636 \
+    --hash=sha256:747ec46290107a490d21fe1ff4183bef8022b848cf9516970cb31de6d9460088 \
+    --hash=sha256:7836587eef675a17d835ec3d98a8c9acdbeb2c1d72b0556f0edf4e855a25e9c1 \
+    --hash=sha256:78e4dd9c34ec7b8b121854eb5342bac8b02aa03075ae8618b6210a06bbb8a115 \
+    --hash=sha256:7b77ee42addbb1c36d35aca55e8cc6d0958f8419e458bb70888d8c69a4ca833d \
+    --hash=sha256:7c1b20a1ace54af7db1f95af85da530fe97407d9063b7aaf9ce6a32f44730778 \
+    --hash=sha256:7f27eec42f6c3c1df09cfc1f6786308f8b525b8efaaf6d6bd76c1f52c6511f6a \
+    --hash=sha256:82c249f2bfa5ecbe4a1a7902c81c0fba52ed9ebd0176ab3047395d02ad96cfcb \
+    --hash=sha256:85fa0b18558eb1427090912bd456a01f71edab0872f4e0f9e4285571941e4090 \
+    --hash=sha256:89ce611b1eac93ce2ade68f1470889e0173d606de20c85a012bfa24be96cf867 \
+    --hash=sha256:8ce789231404ca8fff7f693cdce398abf6d90fd5dae2b1847477196c243b1fbb \
+    --hash=sha256:90d571c98d19a8b6e793b34aa4df4cee1e8fe2862d65cc49185a3a3d0a1a3996 \
+    --hash=sha256:9229d8613bd8401182868fe95688f7581673e1c18ff78855671a4b8284f47bcb \
+    --hash=sha256:93a1f7d857c4fcf7cabb1178058182c789b30d85de379e04f64c15b7e88d66fb \
+    --hash=sha256:967b93f21b426f23ca37329230d5bd122f25516ae2f24a9cea95a30023ff8283 \
+    --hash=sha256:9840be675de208d1f68f84d578eaa4d1a36eee70b16ae31ab933520c49ba1325 \
+    --hash=sha256:9862d077b9ffa015dbe3ce6c081bdf35135948cb89116e26667dd183550833d1 \
+    --hash=sha256:9b5b37c863ad5b0892cc7a4ceb1e435e5e6acd3f2f8d3e11fa56f08d3c67b820 \
+    --hash=sha256:9e64ca2dbea28807f8484c13f684a2f761e69ba2640ec49dacd342763cc265ef \
+    --hash=sha256:9fe4eb0e7f50cdb99b26250d9328faef30b1175a5dbcfd6d0578d18456bac567 \
+    --hash=sha256:a01fe9f1e05025eacdd97590895e2737b9f851d0eb2e017ae9574d9a4f0b6252 \
+    --hash=sha256:a08ad95fcbd595803e0c4280671d808eb170a64ca3f2980dd38e7a72ed8d1fea \
+    --hash=sha256:a4fe27dbbeec445e6e1291e61d61eb212ee9fed6e47998b27de71d70d3e8777d \
+    --hash=sha256:a7d474c5c1f0b9405c1565fafdc4429fa7d986ccbec7ce55bc6a330f36409cad \
+    --hash=sha256:a86dc177eb4c286c19d1823ac296299f59ed8106c9536d2b559f65836e0fb2c6 \
+    --hash=sha256:aa36c35e94ecdb478246dd60db12aba57cfcd0abcad43c927a8876f25734d496 \
+    --hash=sha256:ab915a57c65f7a29353c8014ac4be685c8e4a19e792a79fe133a8e101111438e \
+    --hash=sha256:af55314407714fe77a68a9ccaab90fdb5deb57342585fd4a3a8102b6d4370080 \
+    --hash=sha256:afcb6b275c2d2ba5d8418bf30a9654fa978b4f819c2e8db6311b3525c86fe637 \
+    --hash=sha256:b27961d65639128336b7a7c3f0046dcc62a9443d5ef962e3c84170ac620cec47 \
+    --hash=sha256:b5b95787335c483cd5f29577f42bbe027a412c5431f2f80a749c80d040f7ca9f \
+    --hash=sha256:b73a2b139782a07658fbf170fe4bcdf70fc597fae5ffe75e5b67674c27434a9f \
+    --hash=sha256:b88aca5adbf4625e11118df45acac29616b425833c3be7a05ef63a6a4017bfdb \
+    --hash=sha256:b992778d95b60a21c4d8d4a5f15aaab2bd3c3e16466a72d7f9bfd86e8cea0d4b \
+    --hash=sha256:ba40b7ae0f81c7029583a338853f6607b6d83a341a3dcde8bed1ea58a3af1df9 \
+    --hash=sha256:baae005092e3f200de02699314ac8933ec20abf998ec0be39448f6605bce93df \
+    --hash=sha256:c4bea08a6aad9195ac9b1be6b0c7e8a702a9cec57ce6b713698b4a5afa9c2e33 \
+    --hash=sha256:c6070bcf2173a7146bb9e4735b3c62b2accba459a6eae44deea0eb23e0035a23 \
+    --hash=sha256:c929f9a7249a11e4aa5c157091cfad7f49cc6b13f4eecf9b747104befd9f56f2 \
+    --hash=sha256:c97be90d70f7db3aa041d720bfb95f4869d6063fcdf2bb8333764d97e319b7d0 \
+    --hash=sha256:ce10ddfbe26ed5856d6902162f71b8fe08545380570a885b4ab56aecfdcb07f4 \
+    --hash=sha256:cf1f31f83d16ec344136359001c5e871915c6ab685a3d8dee38e2961b4c81730 \
+    --hash=sha256:d2b25b2eeb35707113b2d570cadc7c612a57f1c5d3e7bb2b13870fe284e08fc0 \
+    --hash=sha256:d33851d85537bbf0f6291ddc97926a754c8f041af759e0aa0230fe939168852b \
+    --hash=sha256:e06cf4852ce8c4442a59bae5a3ea01162b8fcb49ab438d8548b8dc79375dad8a \
+    --hash=sha256:e271beb2b1dabec5cd84eb488bdabf9758d22ad13471e9c356be07ad139b3012 \
+    --hash=sha256:f55d0f242c2d1fcdf802c8fabcff25a9d85550a4cf3a9cf5f2a6b5742c992839 \
+    --hash=sha256:f81cba651db8795f688c589dd11a4fbb834f2e59bbf9bb50908be36e416dc760 \
+    --hash=sha256:fa1fb1b61881c8405829c50e9cc5c875bfdbf685edf57a76817dfb50643e4a1a \
+    --hash=sha256:fa48dac27f41b36735c807d1ab093a8386701bbf00eb6b89a0f69d9fa26b3671 \
+    --hash=sha256:fbfef0666ae9e07abfa2c54c212ac18a1f63e13e0760a769f70b5717742f3ece \
+    --hash=sha256:fe7065e2215e4bba63dc00db9ae654c1ba3950a5fff691475a32f511142fcddb
     # via
     #   -r requirements.in
     #   aio-api-github