diff --git a/eval/compiler/BUILD b/eval/compiler/BUILD
index c5a97ae57..60b8fbbac 100644
--- a/eval/compiler/BUILD
+++ b/eval/compiler/BUILD
@@ -198,6 +198,7 @@ cc_test(
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:status_matchers",
+        "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/types:span",
         "@com_google_cel_spec//proto/cel/expr:checked_cc_proto",
diff --git a/eval/compiler/flat_expr_builder_test.cc b/eval/compiler/flat_expr_builder_test.cc
index 262b66e0f..8f4594f23 100644
--- a/eval/compiler/flat_expr_builder_test.cc
+++ b/eval/compiler/flat_expr_builder_test.cc
@@ -31,6 +31,7 @@
 #include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
 #include "absl/status/status_matchers.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
@@ -2394,10 +2395,10 @@ struct ConstantFoldingTestCase {
 };
 
 class UnknownFunctionImpl : public cel::Function {
-  absl::StatusOr<Value> Invoke(absl::Span<const Value> args,
-                               const google::protobuf::DescriptorPool* absl_nonnull,
-                               google::protobuf::MessageFactory* absl_nonnull,
-                               google::protobuf::Arena* absl_nonnull) const override {
+  absl::StatusOr<Value> Invoke(
+      absl::Span<const Value> args, const google::protobuf::DescriptorPool* absl_nonnull,
+      google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull,
+      const cel::ActivationInterface* absl_nullable) const override {
     return cel::UnknownValue();
   }
 };
diff --git a/eval/eval/function_step.cc b/eval/eval/function_step.cc
index a860a4bb4..70e363f7d 100644
--- a/eval/eval/function_step.cc
+++ b/eval/eval/function_step.cc
@@ -178,9 +178,9 @@ inline absl::StatusOr<Value> Invoke(
     const cel::FunctionOverloadReference& overload, int64_t expr_id,
     absl::Span<const cel::Value> args, ExecutionFrameBase& frame) {
   CEL_ASSIGN_OR_RETURN(
-      Value result,
-      overload.implementation.Invoke(args, frame.descriptor_pool(),
-                                     frame.message_factory(), frame.arena()));
+      Value result, overload.implementation.Invoke(
+                        args, frame.descriptor_pool(), frame.message_factory(),
+                        frame.arena(), &frame.activation()));
 
   if (frame.unknown_function_results_enabled() &&
       IsUnknownFunctionResultError(result)) {
diff --git a/eval/public/BUILD b/eval/public/BUILD
index 269309ca4..0f95e51a9 100644
--- a/eval/public/BUILD
+++ b/eval/public/BUILD
@@ -197,6 +197,7 @@ cc_library(
         "//common:value",
         "//eval/internal:interop",
         "//internal:status_macros",
+        "//runtime:activation_interface",
         "//runtime:function",
         "@com_google_absl//absl/base:nullability",
         "@com_google_absl//absl/status",
diff --git a/eval/public/cel_function.cc b/eval/public/cel_function.cc
index bee39ec8e..eb44b23ab 100644
--- a/eval/public/cel_function.cc
+++ b/eval/public/cel_function.cc
@@ -10,6 +10,7 @@
 #include "eval/internal/interop.h"
 #include "eval/public/cel_value.h"
 #include "internal/status_macros.h"
+#include "runtime/activation_interface.h"
 #include "google/protobuf/arena.h"
 #include "google/protobuf/descriptor.h"
 #include "google/protobuf/message.h"
@@ -57,7 +58,8 @@ absl::StatusOr<Value> CelFunction::Invoke(
     absl::Span<const cel::Value> arguments,
     const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
     google::protobuf::MessageFactory* absl_nonnull message_factory,
-    google::protobuf::Arena* absl_nonnull arena) const {
+    google::protobuf::Arena* absl_nonnull arena,
+    const cel::ActivationInterface* absl_nullable activation) const {
   std::vector<CelValue> legacy_args;
   legacy_args.reserve(arguments.size());
 
diff --git a/eval/public/cel_function.h b/eval/public/cel_function.h
index c978c6f67..8a828087c 100644
--- a/eval/public/cel_function.h
+++ b/eval/public/cel_function.h
@@ -69,7 +69,8 @@ class CelFunction : public ::cel::Function {
       absl::Span<const cel::Value> arguments,
       const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
       google::protobuf::MessageFactory* absl_nonnull message_factory,
-      google::protobuf::Arena* absl_nonnull arena) const override;
+      google::protobuf::Arena* absl_nonnull arena,
+      const cel::ActivationInterface* absl_nullable activation) const override;
 
   // CelFunction descriptor
   const CelFunctionDescriptor& descriptor() const { return descriptor_; }
diff --git a/eval/public/cel_function_registry.cc b/eval/public/cel_function_registry.cc
index 62cfbca2f..751aa4c53 100644
--- a/eval/public/cel_function_registry.cc
+++ b/eval/public/cel_function_registry.cc
@@ -50,7 +50,7 @@ class ProxyToModernCelFunction : public CelFunction {
         auto modern_result,
         implementation_->Invoke(
             modern_args, google::protobuf::DescriptorPool::generated_pool(),
-            google::protobuf::MessageFactory::generated_factory(), arena));
+            google::protobuf::MessageFactory::generated_factory(), arena, nullptr));
 
     *result = cel::interop_internal::ModernValueToLegacyValueOrDie(
         arena, modern_result);
diff --git a/runtime/BUILD b/runtime/BUILD
index 3079bcdd0..2ab8ad11c 100644
--- a/runtime/BUILD
+++ b/runtime/BUILD
@@ -500,13 +500,11 @@ cc_library(
         ":function",
         ":register_function_helper",
         "//common:function_descriptor",
-        "//common:kind",
         "//common:value",
         "//internal:status_macros",
         "//runtime/internal:function_adapter",
         "@com_google_absl//absl/base:nullability",
         "@com_google_absl//absl/functional:any_invocable",
-        "@com_google_absl//absl/functional:bind_front",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
@@ -526,10 +524,12 @@ cc_test(
         "//common:value",
         "//common:value_testing",
         "//internal:testing",
+        "@com_google_absl//absl/base:nullability",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/time",
+        "@com_google_protobuf//:protobuf",
     ],
 )
 
diff --git a/runtime/activation_test.cc b/runtime/activation_test.cc
index 30851341a..893ed37f2 100644
--- a/runtime/activation_test.cc
+++ b/runtime/activation_test.cc
@@ -66,10 +66,10 @@ class FunctionImpl : public cel::Function {
  public:
   FunctionImpl() = default;
 
-  absl::StatusOr<Value> Invoke(absl::Span<const Value> args,
-                               const google::protobuf::DescriptorPool* absl_nonnull,
-                               google::protobuf::MessageFactory* absl_nonnull,
-                               google::protobuf::Arena* absl_nonnull) const override {
+  absl::StatusOr<Value> Invoke(
+      absl::Span<const Value> args, const google::protobuf::DescriptorPool* absl_nonnull,
+      google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull,
+      const ActivationInterface* absl_nullable) const override {
     return NullValue();
   }
 };
diff --git a/runtime/function.h b/runtime/function.h
index c2a3d257a..d6797cd53 100644
--- a/runtime/function.h
+++ b/runtime/function.h
@@ -25,6 +25,8 @@
 
 namespace cel {
 
+class ActivationInterface;
+
 // Interface for extension functions.
 //
 // The host for the CEL environment may provide implementations to define custom
@@ -47,7 +49,8 @@ class Function {
       absl::Span<const Value> args,
       const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
       google::protobuf::MessageFactory* absl_nonnull message_factory,
-      google::protobuf::Arena* absl_nonnull arena) const = 0;
+      google::protobuf::Arena* absl_nonnull arena,
+      const ActivationInterface* absl_nullable activation) const = 0;
 };
 
 }  // namespace cel
diff --git a/runtime/function_adapter.h b/runtime/function_adapter.h
index f551a2345..27762b103 100644
--- a/runtime/function_adapter.h
+++ b/runtime/function_adapter.h
@@ -135,11 +135,12 @@ struct ToArgsImpl {
         Op&& op, const TupleType& argbuffer,
         const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
         google::protobuf::MessageFactory* absl_nonnull message_factory,
-        google::protobuf::Arena* absl_nonnull arena) {
+        google::protobuf::Arena* absl_nonnull arena,
+        const ActivationInterface* absl_nullable activation) {
       return std::forward<Op>(op)(
           runtime_internal::AdaptedTypeTraits<typename Es::type>::ToArg(
               std::get<Es::index>(argbuffer))...,
-          descriptor_pool, message_factory, arena);
+          descriptor_pool, message_factory, arena, activation);
     }
   };
 
@@ -156,12 +157,13 @@ struct ToArgsHelper {
       Op&& op, const TupleType& argbuffer,
       const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
       google::protobuf::MessageFactory* absl_nonnull message_factory,
-      google::protobuf::Arena* absl_nonnull arena) {
+      google::protobuf::Arena* absl_nonnull arena,
+      const ActivationInterface* absl_nullable activation) {
     using Impl = ToArgsImpl<Args...>;
     using Zip = decltype(Impl::MakeZip(std::index_sequence_for<Args...>{}));
     return Zip::template ToArgs<ResultType>(std::forward<Op>(op), argbuffer,
                                             descriptor_pool, message_factory,
-                                            arena);
+                                            arena, activation);
   }
 };
 
@@ -194,19 +196,35 @@ class NullaryFunctionAdapter
  public:
   using FunctionType = absl::AnyInvocable<T(
       const google::protobuf::DescriptorPool* absl_nonnull,
-      google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull) const>;
+      google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull,
+      const ActivationInterface* absl_nullable) const>;
 
   static std::unique_ptr<cel::Function> WrapFunction(FunctionType fn) {
     return std::make_unique<UnaryFunctionImpl>(std::move(fn));
   }
 
-  static std::unique_ptr<cel::Function> WrapFunction(
-      absl::AnyInvocable<T() const> function) {
+  template <typename F>
+    requires std::is_invocable_v<F, const google::protobuf::DescriptorPool* absl_nonnull,
+                                 google::protobuf::MessageFactory* absl_nonnull,
+                                 google::protobuf::Arena* absl_nonnull>
+  static std::unique_ptr<cel::Function> WrapFunction(F&& function) {
     return WrapFunction(
-        [function = std::move(function)](
-            const google::protobuf::DescriptorPool* absl_nonnull,
-            google::protobuf::MessageFactory* absl_nonnull,
-            google::protobuf::Arena* absl_nonnull) -> T { return function(); });
+        [function = std::forward<F>(function)](
+            const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+            google::protobuf::MessageFactory* absl_nonnull message_factory,
+            google::protobuf::Arena* absl_nonnull arena, auto) -> T {
+          return function(descriptor_pool, message_factory, arena);
+        });
+  }
+
+  template <typename F>
+    requires std::is_invocable_v<F>
+  static std::unique_ptr<cel::Function> WrapFunction(F&& function) {
+    return WrapFunction([function = std::forward<F>(function)](
+                            const google::protobuf::DescriptorPool* absl_nonnull,
+                            google::protobuf::MessageFactory* absl_nonnull,
+                            google::protobuf::Arena* absl_nonnull,
+                            auto) -> T { return function(); });
   }
 
   static FunctionDescriptor CreateDescriptor(absl::string_view name,
@@ -223,7 +241,8 @@ class NullaryFunctionAdapter
         absl::Span<const Value> args,
         const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
         google::protobuf::MessageFactory* absl_nonnull message_factory,
-        google::protobuf::Arena* absl_nonnull arena) const override {
+        google::protobuf::Arena* absl_nonnull arena,
+        const ActivationInterface* absl_nullable activation) const override {
       if (args.size() != 0) {
         return absl::InvalidArgumentError(
             "unexpected number of arguments for nullary function");
@@ -231,9 +250,9 @@ class NullaryFunctionAdapter
 
       if constexpr (std::is_same_v<T, Value> ||
                     std::is_same_v<T, absl::StatusOr<Value>>) {
-        return fn_(descriptor_pool, message_factory, arena);
+        return fn_(descriptor_pool, message_factory, arena, activation);
       } else {
-        T result = fn_(descriptor_pool, message_factory, arena);
+        T result = fn_(descriptor_pool, message_factory, arena, activation);
 
         return runtime_internal::AdaptedToValueVisitor{}(std::move(result));
       }
@@ -270,19 +289,36 @@ class UnaryFunctionAdapter : public RegisterHelper<UnaryFunctionAdapter<T, U>> {
  public:
   using FunctionType = absl::AnyInvocable<T(
       U, const google::protobuf::DescriptorPool* absl_nonnull,
-      google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull) const>;
+      google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull,
+      const ActivationInterface* absl_nullable) const>;
 
   static std::unique_ptr<cel::Function> WrapFunction(FunctionType fn) {
     return std::make_unique<UnaryFunctionImpl>(std::move(fn));
   }
 
-  static std::unique_ptr<cel::Function> WrapFunction(
-      absl::AnyInvocable<T(U) const> function) {
+  template <typename F>
+    requires std::is_invocable_v<
+        F, U, const google::protobuf::DescriptorPool* absl_nonnull,
+        google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull>
+  static std::unique_ptr<cel::Function> WrapFunction(F&& function) {
     return WrapFunction(
-        [function = std::move(function)](
-            U arg1, const google::protobuf::DescriptorPool* absl_nonnull,
-            google::protobuf::MessageFactory* absl_nonnull,
-            google::protobuf::Arena* absl_nonnull) -> T { return function(arg1); });
+        [function = std::forward<F>(function)](
+            U arg1, const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+            google::protobuf::MessageFactory* absl_nonnull message_factory,
+            google::protobuf::Arena* absl_nonnull arena, auto) -> T {
+          return function(std::forward<U>(arg1), descriptor_pool,
+                          message_factory, arena);
+        });
+  }
+
+  template <typename F>
+    requires std::is_invocable_v<F, U>
+  static std::unique_ptr<cel::Function> WrapFunction(F&& function) {
+    return WrapFunction([function = std::forward<F>(function)](
+                            U arg1, const google::protobuf::DescriptorPool* absl_nonnull,
+                            google::protobuf::MessageFactory* absl_nonnull,
+                            google::protobuf::Arena* absl_nonnull,
+                            auto) -> T { return function(arg1); });
   }
 
   static FunctionDescriptor CreateDescriptor(absl::string_view name,
@@ -300,7 +336,8 @@ class UnaryFunctionAdapter : public RegisterHelper<UnaryFunctionAdapter<T, U>> {
         absl::Span<const Value> args,
         const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
         google::protobuf::MessageFactory* absl_nonnull message_factory,
-        google::protobuf::Arena* absl_nonnull arena) const override {
+        google::protobuf::Arena* absl_nonnull arena,
+        const ActivationInterface* absl_nullable activation) const override {
       using ArgTraits = runtime_internal::AdaptedTypeTraits<U>;
       if (args.size() != 1) {
         return absl::InvalidArgumentError(
@@ -313,10 +350,10 @@ class UnaryFunctionAdapter : public RegisterHelper<UnaryFunctionAdapter<T, U>> {
       if constexpr (std::is_same_v<T, Value> ||
                     std::is_same_v<T, absl::StatusOr<Value>>) {
         return fn_(ArgTraits::ToArg(arg1), descriptor_pool, message_factory,
-                   arena);
+                   arena, activation);
       } else {
         T result = fn_(ArgTraits::ToArg(arg1), descriptor_pool, message_factory,
-                       arena);
+                       arena, activation);
 
         return runtime_internal::AdaptedToValueVisitor{}(std::move(result));
       }
@@ -400,19 +437,39 @@ class BinaryFunctionAdapter
  public:
   using FunctionType = absl::AnyInvocable<T(
       U, V, const google::protobuf::DescriptorPool* absl_nonnull,
-      google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull) const>;
+      google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull,
+      const ActivationInterface* absl_nullable) const>;
 
   static std::unique_ptr<cel::Function> WrapFunction(FunctionType fn) {
     return std::make_unique<BinaryFunctionImpl>(std::move(fn));
   }
 
-  static std::unique_ptr<cel::Function> WrapFunction(
-      absl::AnyInvocable<T(U, V) const> function) {
+  template <typename F>
+    requires std::is_invocable_v<
+        F, U, V, const google::protobuf::DescriptorPool* absl_nonnull,
+        google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull>
+  static std::unique_ptr<cel::Function> WrapFunction(F&& function) {
     return WrapFunction(
-        [function = std::move(function)](
-            U arg1, V arg2, const google::protobuf::DescriptorPool* absl_nonnull,
-            google::protobuf::MessageFactory* absl_nonnull,
-            google::protobuf::Arena* absl_nonnull) -> T { return function(arg1, arg2); });
+        [function = std::forward<F>(function)](
+            U arg1, V arg2,
+            const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+            google::protobuf::MessageFactory* absl_nonnull message_factory,
+            google::protobuf::Arena* absl_nonnull arena, auto) -> T {
+          return function(std::forward<U>(arg1), std::forward<V>(arg2),
+                          descriptor_pool, message_factory, arena);
+        });
+  }
+
+  template <typename F>
+    requires std::is_invocable_v<F, U, V>
+  static std::unique_ptr<cel::Function> WrapFunction(F&& function) {
+    return WrapFunction([function = std::forward<F>(function)](
+                            U arg1, V arg2,
+                            const google::protobuf::DescriptorPool* absl_nonnull,
+                            google::protobuf::MessageFactory* absl_nonnull,
+                            google::protobuf::Arena* absl_nonnull, auto) -> T {
+      return function(std::forward<U>(arg1), std::forward<V>(arg2));
+    });
   }
 
   static FunctionDescriptor CreateDescriptor(absl::string_view name,
@@ -432,7 +489,8 @@ class BinaryFunctionAdapter
         absl::Span<const Value> args,
         const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
         google::protobuf::MessageFactory* absl_nonnull message_factory,
-        google::protobuf::Arena* absl_nonnull arena) const override {
+        google::protobuf::Arena* absl_nonnull arena,
+        const ActivationInterface* absl_nullable activation) const override {
       using Arg1Traits = runtime_internal::AdaptedTypeTraits<U>;
       using Arg2Traits = runtime_internal::AdaptedTypeTraits<V>;
       if (args.size() != 2) {
@@ -449,10 +507,10 @@ class BinaryFunctionAdapter
       if constexpr (std::is_same_v<T, Value> ||
                     std::is_same_v<T, absl::StatusOr<Value>>) {
         return fn_(Arg1Traits::ToArg(arg1), Arg2Traits::ToArg(arg2),
-                   descriptor_pool, message_factory, arena);
+                   descriptor_pool, message_factory, arena, activation);
       } else {
         T result = fn_(Arg1Traits::ToArg(arg1), Arg2Traits::ToArg(arg2),
-                       descriptor_pool, message_factory, arena);
+                       descriptor_pool, message_factory, arena, activation);
 
         return runtime_internal::AdaptedToValueVisitor{}(std::move(result));
       }
@@ -469,20 +527,40 @@ class TernaryFunctionAdapter
  public:
   using FunctionType = absl::AnyInvocable<T(
       U, V, W, const google::protobuf::DescriptorPool* absl_nonnull,
-      google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull) const>;
+      google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull,
+      const ActivationInterface* absl_nullable) const>;
 
   static std::unique_ptr<cel::Function> WrapFunction(FunctionType fn) {
     return std::make_unique<TernaryFunctionImpl>(std::move(fn));
   }
 
-  static std::unique_ptr<cel::Function> WrapFunction(
-      absl::AnyInvocable<T(U, V, W) const> function) {
-    return WrapFunction([function = std::move(function)](
+  template <typename F>
+    requires std::is_invocable_v<
+        F, U, V, W, const google::protobuf::DescriptorPool* absl_nonnull,
+        google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull>
+  static std::unique_ptr<cel::Function> WrapFunction(F&& function) {
+    return WrapFunction(
+        [function = std::forward<F>(function)](
+            U arg1, V arg2, W arg3,
+            const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+            google::protobuf::MessageFactory* absl_nonnull message_factory,
+            google::protobuf::Arena* absl_nonnull arena, auto) -> T {
+          return function(std::forward<U>(arg1), std::forward<V>(arg2),
+                          std::forward<W>(arg3), descriptor_pool,
+                          message_factory, arena);
+        });
+  }
+
+  template <typename F>
+    requires std::is_invocable_v<F, U, V, W>
+  static std::unique_ptr<cel::Function> WrapFunction(F&& function) {
+    return WrapFunction([function = std::forward<F>(function)](
                             U arg1, V arg2, W arg3,
                             const google::protobuf::DescriptorPool* absl_nonnull,
                             google::protobuf::MessageFactory* absl_nonnull,
-                            google::protobuf::Arena* absl_nonnull) -> T {
-      return function(arg1, arg2, arg3);
+                            google::protobuf::Arena* absl_nonnull, auto) -> T {
+      return function(std::forward<U>(arg1), std::forward<V>(arg2),
+                      std::forward<W>(arg3));
     });
   }
 
@@ -504,7 +582,8 @@ class TernaryFunctionAdapter
         absl::Span<const Value> args,
         const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
         google::protobuf::MessageFactory* absl_nonnull message_factory,
-        google::protobuf::Arena* absl_nonnull arena) const override {
+        google::protobuf::Arena* absl_nonnull arena,
+        const ActivationInterface* absl_nullable activation) const override {
       using Arg1Traits = runtime_internal::AdaptedTypeTraits<U>;
       using Arg2Traits = runtime_internal::AdaptedTypeTraits<V>;
       using Arg3Traits = runtime_internal::AdaptedTypeTraits<W>;
@@ -526,11 +605,11 @@ class TernaryFunctionAdapter
                     std::is_same_v<T, absl::StatusOr<Value>>) {
         return fn_(Arg1Traits::ToArg(arg1), Arg2Traits::ToArg(arg2),
                    Arg3Traits::ToArg(arg3), descriptor_pool, message_factory,
-                   arena);
+                   arena, activation);
       } else {
         T result = fn_(Arg1Traits::ToArg(arg1), Arg2Traits::ToArg(arg2),
                        Arg3Traits::ToArg(arg3), descriptor_pool,
-                       message_factory, arena);
+                       message_factory, arena, activation);
 
         return runtime_internal::AdaptedToValueVisitor{}(std::move(result));
       }
@@ -547,20 +626,40 @@ class QuaternaryFunctionAdapter
  public:
   using FunctionType = absl::AnyInvocable<T(
       U, V, W, X, const google::protobuf::DescriptorPool* absl_nonnull,
-      google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull) const>;
+      google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull,
+      const ActivationInterface* absl_nullable) const>;
 
   static std::unique_ptr<cel::Function> WrapFunction(FunctionType fn) {
     return std::make_unique<QuaternaryFunctionImpl>(std::move(fn));
   }
 
-  static std::unique_ptr<cel::Function> WrapFunction(
-      absl::AnyInvocable<T(U, V, W, X) const> function) {
-    return WrapFunction([function = std::move(function)](
+  template <typename F>
+    requires std::is_invocable_v<
+        F, U, V, W, X, const google::protobuf::DescriptorPool* absl_nonnull,
+        google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull>
+  static std::unique_ptr<cel::Function> WrapFunction(F&& function) {
+    return WrapFunction(
+        [function = std::forward<F>(function)](
+            U arg1, V arg2, W arg3, X arg4,
+            const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+            google::protobuf::MessageFactory* absl_nonnull message_factory,
+            google::protobuf::Arena* absl_nonnull arena, auto) -> T {
+          return function(std::forward<U>(arg1), std::forward<V>(arg2),
+                          std::forward<W>(arg3), std::forward<X>(arg4),
+                          descriptor_pool, message_factory, arena);
+        });
+  }
+
+  template <typename F>
+    requires std::is_invocable_v<F, U, V, W, X>
+  static std::unique_ptr<cel::Function> WrapFunction(F&& function) {
+    return WrapFunction([function = std::forward<F>(function)](
                             U arg1, V arg2, W arg3, X arg4,
                             const google::protobuf::DescriptorPool* absl_nonnull,
                             google::protobuf::MessageFactory* absl_nonnull,
-                            google::protobuf::Arena* absl_nonnull) -> T {
-      return function(arg1, arg2, arg3, arg4);
+                            google::protobuf::Arena* absl_nonnull, auto) -> T {
+      return function(std::forward<U>(arg1), std::forward<V>(arg2),
+                      std::forward<W>(arg3), std::forward<X>(arg4));
     });
   }
 
@@ -583,7 +682,8 @@ class QuaternaryFunctionAdapter
         absl::Span<const Value> args,
         const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
         google::protobuf::MessageFactory* absl_nonnull message_factory,
-        google::protobuf::Arena* absl_nonnull arena) const override {
+        google::protobuf::Arena* absl_nonnull arena,
+        const ActivationInterface* absl_nullable activation) const override {
       using Arg1Traits = runtime_internal::AdaptedTypeTraits<U>;
       using Arg2Traits = runtime_internal::AdaptedTypeTraits<V>;
       using Arg3Traits = runtime_internal::AdaptedTypeTraits<W>;
@@ -609,11 +709,11 @@ class QuaternaryFunctionAdapter
                     std::is_same_v<T, absl::StatusOr<Value>>) {
         return fn_(Arg1Traits::ToArg(arg1), Arg2Traits::ToArg(arg2),
                    Arg3Traits::ToArg(arg3), Arg4Traits::ToArg(arg4),
-                   descriptor_pool, message_factory, arena);
+                   descriptor_pool, message_factory, arena, activation);
       } else {
         T result = fn_(Arg1Traits::ToArg(arg1), Arg2Traits::ToArg(arg2),
                        Arg3Traits::ToArg(arg3), Arg4Traits::ToArg(arg4),
-                       descriptor_pool, message_factory, arena);
+                       descriptor_pool, message_factory, arena, activation);
 
         return runtime_internal::AdaptedToValueVisitor{}(std::move(result));
       }
@@ -656,7 +756,8 @@ class NaryFunctionAdapter
   using FunctionType = absl::AnyInvocable<T(
       Args..., const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
       google::protobuf::MessageFactory* absl_nonnull message_factory,
-      google::protobuf::Arena* absl_nonnull arena) const>;
+      google::protobuf::Arena* absl_nonnull arena,
+      const ActivationInterface* absl_nullable activation) const>;
 
   static FunctionDescriptor CreateDescriptor(absl::string_view name,
                                              bool receiver_style,
@@ -670,13 +771,30 @@ class NaryFunctionAdapter
     return std::make_unique<NaryFunctionImpl>(std::move(fn));
   }
 
-  static std::unique_ptr<cel::Function> WrapFunction(
-      absl::AnyInvocable<T(Args...) const> function) {
+  template <typename F>
+    requires std::is_invocable_v<
+        F, Args..., const google::protobuf::DescriptorPool* absl_nonnull,
+        google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull>
+  static std::unique_ptr<cel::Function> WrapFunction(F&& function) {
+    return WrapFunction(
+        [function = std::forward<F>(function)](
+            Args... args,
+            const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+            google::protobuf::MessageFactory* absl_nonnull message_factory,
+            google::protobuf::Arena* absl_nonnull arena, auto) -> T {
+          return function(std::forward<Args>(args)..., descriptor_pool,
+                          message_factory, arena);
+        });
+  }
+
+  template <typename F>
+    requires std::is_invocable_v<F, Args...>
+  static std::unique_ptr<cel::Function> WrapFunction(F&& function) {
     return WrapFunction(
-        [function = std::move(function)](
+        [function = std::forward<F>(function)](
             Args... args, const google::protobuf::DescriptorPool* absl_nonnull,
-            google::protobuf::MessageFactory* absl_nonnull,
-            google::protobuf::Arena* absl_nonnull) -> T { return function(args...); });
+            google::protobuf::MessageFactory* absl_nonnull, google::protobuf::Arena* absl_nonnull,
+            auto) -> T { return function(std::forward<Args>(args)...); });
   }
 
  private:
@@ -691,7 +809,8 @@ class NaryFunctionAdapter
         absl::Span<const Value> args,
         const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
         google::protobuf::MessageFactory* absl_nonnull message_factory,
-        google::protobuf::Arena* absl_nonnull arena) const override {
+        google::protobuf::Arena* absl_nonnull arena,
+        const ActivationInterface* absl_nullable activation) const override {
       if (args.size() != sizeof...(Args)) {
         return absl::InvalidArgumentError(
             absl::StrCat("unexpected number of arguments for ", sizeof...(Args),
@@ -703,10 +822,12 @@ class NaryFunctionAdapter
       if constexpr (std::is_same_v<T, Value> ||
                     std::is_same_v<T, absl::StatusOr<Value>>) {
         return runtime_internal::ToArgsHelper<Args...>::template Apply<T>(
-            fn_, arg_buffer, descriptor_pool, message_factory, arena);
+            fn_, arg_buffer, descriptor_pool, message_factory, arena,
+            activation);
       } else {
         T result = runtime_internal::ToArgsHelper<Args...>::template Apply<T>(
-            fn_, arg_buffer, descriptor_pool, message_factory, arena);
+            fn_, arg_buffer, descriptor_pool, message_factory, arena,
+            activation);
         return runtime_internal::AdaptedToValueVisitor{}(std::move(result));
       }
     }
diff --git a/runtime/function_adapter_test.cc b/runtime/function_adapter_test.cc
index aad5e4086..20f52549b 100644
--- a/runtime/function_adapter_test.cc
+++ b/runtime/function_adapter_test.cc
@@ -18,6 +18,7 @@
 #include <memory>
 #include <vector>
 
+#include "absl/base/nullability.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -28,6 +29,9 @@
 #include "common/value_testing.h"
 #include "internal/testing.h"
 #include "runtime/function.h"
+#include "google/protobuf/arena.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/message.h"
 
 namespace cel {
 namespace {
@@ -47,8 +51,8 @@ TEST_F(FunctionAdapterTest, UnaryFunctionAdapterWrapFunctionInt) {
 
   std::vector<Value> args{IntValue(40)};
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<IntValue>());
   EXPECT_EQ(result.GetInt().NativeValue(), 42);
@@ -61,8 +65,8 @@ TEST_F(FunctionAdapterTest, UnaryFunctionAdapterWrapFunctionDouble) {
 
   std::vector<Value> args{DoubleValue(40.0)};
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<DoubleValue>());
   EXPECT_EQ(result.GetDouble().NativeValue(), 80.0);
@@ -75,8 +79,8 @@ TEST_F(FunctionAdapterTest, UnaryFunctionAdapterWrapFunctionUint) {
 
   std::vector<Value> args{UintValue(44)};
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<UintValue>());
   EXPECT_EQ(result.GetUint().NativeValue(), 42);
@@ -89,8 +93,8 @@ TEST_F(FunctionAdapterTest, UnaryFunctionAdapterWrapFunctionBool) {
 
   std::vector<Value> args{BoolValue(true)};
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<BoolValue>());
   EXPECT_EQ(result.GetBool().NativeValue(), false);
@@ -104,8 +108,8 @@ TEST_F(FunctionAdapterTest, UnaryFunctionAdapterWrapFunctionTimestamp) {
   std::vector<Value> args;
   args.emplace_back() = TimestampValue(absl::UnixEpoch());
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<TimestampValue>());
   EXPECT_EQ(result.GetTimestamp().NativeValue(),
@@ -120,8 +124,8 @@ TEST_F(FunctionAdapterTest, UnaryFunctionAdapterWrapFunctionDuration) {
   std::vector<Value> args;
   args.emplace_back() = DurationValue(absl::Seconds(6));
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<DurationValue>());
   EXPECT_EQ(result.GetDuration().NativeValue(), absl::Seconds(8));
@@ -137,8 +141,8 @@ TEST_F(FunctionAdapterTest, UnaryFunctionAdapterWrapFunctionString) {
   std::vector<Value> args;
   args.emplace_back() = StringValue("string");
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<StringValue>());
   EXPECT_EQ(result.GetString().ToString(), "pre_string");
@@ -154,8 +158,8 @@ TEST_F(FunctionAdapterTest, UnaryFunctionAdapterWrapFunctionBytes) {
   std::vector<Value> args;
   args.emplace_back() = BytesValue("bytes");
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<BytesValue>());
   EXPECT_EQ(result.GetBytes().ToString(), "pre_bytes");
@@ -168,8 +172,8 @@ TEST_F(FunctionAdapterTest, UnaryFunctionAdapterWrapFunctionAny) {
 
   std::vector<Value> args{UintValue(44)};
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<UintValue>());
   EXPECT_EQ(result.GetUint().NativeValue(), 42);
@@ -184,8 +188,8 @@ TEST_F(FunctionAdapterTest, UnaryFunctionAdapterWrapFunctionReturnError) {
 
   std::vector<Value> args{UintValue(44)};
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<ErrorValue>());
   EXPECT_THAT(result.GetError().NativeValue(),
@@ -203,9 +207,9 @@ TEST_F(FunctionAdapterTest, UnaryFunctionAdapterWrapFunctionPropagateStatus) {
       });
 
   std::vector<Value> args{UintValue(44)};
-  EXPECT_THAT(
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()),
-      StatusIs(absl::StatusCode::kInternal, "test_error"));
+  EXPECT_THAT(wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                              arena(), nullptr),
+              StatusIs(absl::StatusCode::kInternal, "test_error"));
 }
 
 TEST_F(FunctionAdapterTest,
@@ -217,8 +221,8 @@ TEST_F(FunctionAdapterTest,
 
   std::vector<Value> args{UintValue(44)};
   ASSERT_OK_AND_ASSIGN(
-      Value result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      Value result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                    arena(), nullptr));
   EXPECT_EQ(result.GetUint().NativeValue(), 44);
 }
 
@@ -230,10 +234,10 @@ TEST_F(FunctionAdapterTest,
       [](uint64_t x) -> absl::StatusOr<uint64_t> { return 42; });
 
   std::vector<Value> args{UintValue(44), UintValue(43)};
-  EXPECT_THAT(
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()),
-      StatusIs(absl::StatusCode::kInvalidArgument,
-               "unexpected number of arguments for unary function"));
+  EXPECT_THAT(wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                              arena(), nullptr),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       "unexpected number of arguments for unary function"));
 }
 
 TEST_F(FunctionAdapterTest, UnaryFunctionAdapterWrapFunctionWrongArgTypeError) {
@@ -243,10 +247,10 @@ TEST_F(FunctionAdapterTest, UnaryFunctionAdapterWrapFunctionWrongArgTypeError) {
       [](uint64_t x) -> absl::StatusOr<uint64_t> { return 42; });
 
   std::vector<Value> args{DoubleValue(44)};
-  EXPECT_THAT(
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()),
-      StatusIs(absl::StatusCode::kInvalidArgument,
-               HasSubstr("expected uint value")));
+  EXPECT_THAT(wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                              arena(), nullptr),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("expected uint value")));
 }
 
 TEST_F(FunctionAdapterTest, UnaryFunctionAdapterCreateDescriptorInt) {
@@ -368,8 +372,8 @@ TEST_F(FunctionAdapterTest, BinaryFunctionAdapterWrapFunctionInt) {
 
   std::vector<Value> args{IntValue(21), IntValue(21)};
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<IntValue>());
   EXPECT_EQ(result.GetInt().NativeValue(), 42);
@@ -382,8 +386,8 @@ TEST_F(FunctionAdapterTest, BinaryFunctionAdapterWrapFunctionDouble) {
 
   std::vector<Value> args{DoubleValue(40.0), DoubleValue(2.0)};
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<DoubleValue>());
   EXPECT_EQ(result.GetDouble().NativeValue(), 80.0);
@@ -396,8 +400,8 @@ TEST_F(FunctionAdapterTest, BinaryFunctionAdapterWrapFunctionUint) {
 
   std::vector<Value> args{UintValue(44), UintValue(2)};
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<UintValue>());
   EXPECT_EQ(result.GetUint().NativeValue(), 42);
@@ -410,8 +414,8 @@ TEST_F(FunctionAdapterTest, BinaryFunctionAdapterWrapFunctionBool) {
 
   std::vector<Value> args{BoolValue(false), BoolValue(true)};
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<BoolValue>());
   EXPECT_EQ(result.GetBool().NativeValue(), true);
@@ -428,8 +432,8 @@ TEST_F(FunctionAdapterTest, BinaryFunctionAdapterWrapFunctionTimestamp) {
   args.emplace_back() = TimestampValue(absl::UnixEpoch() + absl::Seconds(2));
 
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<TimestampValue>());
   EXPECT_EQ(result.GetTimestamp().NativeValue(),
@@ -449,8 +453,8 @@ TEST_F(FunctionAdapterTest, BinaryFunctionAdapterWrapFunctionDuration) {
   args.emplace_back() = DurationValue(absl::Seconds(2));
 
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<DurationValue>());
   EXPECT_EQ(result.GetDuration().NativeValue(), absl::Seconds(5));
@@ -471,8 +475,8 @@ TEST_F(FunctionAdapterTest, BinaryFunctionAdapterWrapFunctionString) {
   args.emplace_back() = StringValue("def");
 
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<StringValue>());
   EXPECT_EQ(result.GetString().ToString(), "abcdef");
@@ -493,8 +497,8 @@ TEST_F(FunctionAdapterTest, BinaryFunctionAdapterWrapFunctionBytes) {
   args.emplace_back() = BytesValue("def");
 
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<BytesValue>());
   EXPECT_EQ(result.GetBytes().ToString(), "abcdef");
@@ -510,8 +514,8 @@ TEST_F(FunctionAdapterTest, BinaryFunctionAdapterWrapFunctionAny) {
 
   std::vector<Value> args{UintValue(44), DoubleValue(2)};
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<UintValue>());
   EXPECT_EQ(result.GetUint().NativeValue(), 42);
@@ -526,8 +530,8 @@ TEST_F(FunctionAdapterTest, BinaryFunctionAdapterWrapFunctionReturnError) {
 
   std::vector<Value> args{IntValue(44), UintValue(44)};
   ASSERT_OK_AND_ASSIGN(
-      auto result,
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()));
+      auto result, wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                                   arena(), nullptr));
 
   ASSERT_TRUE(result->Is<ErrorValue>());
   EXPECT_THAT(result.GetError().NativeValue(),
@@ -545,9 +549,9 @@ TEST_F(FunctionAdapterTest, BinaryFunctionAdapterWrapFunctionPropagateStatus) {
       });
 
   std::vector<Value> args{IntValue(43), UintValue(44)};
-  EXPECT_THAT(
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()),
-      StatusIs(absl::StatusCode::kInternal, "test_error"));
+  EXPECT_THAT(wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                              arena(), nullptr),
+              StatusIs(absl::StatusCode::kInternal, "test_error"));
 }
 
 TEST_F(FunctionAdapterTest,
@@ -558,10 +562,10 @@ TEST_F(FunctionAdapterTest,
       [](uint64_t x, double y) -> absl::StatusOr<uint64_t> { return 42; });
 
   std::vector<Value> args{UintValue(44)};
-  EXPECT_THAT(
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()),
-      StatusIs(absl::StatusCode::kInvalidArgument,
-               "unexpected number of arguments for binary function"));
+  EXPECT_THAT(wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                              arena(), nullptr),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       "unexpected number of arguments for binary function"));
 }
 
 TEST_F(FunctionAdapterTest,
@@ -572,10 +576,10 @@ TEST_F(FunctionAdapterTest,
       [](int64_t x, int64_t y) -> absl::StatusOr<uint64_t> { return 42; });
 
   std::vector<Value> args{DoubleValue(44), DoubleValue(44)};
-  EXPECT_THAT(
-      wrapped->Invoke(args, descriptor_pool(), message_factory(), arena()),
-      StatusIs(absl::StatusCode::kInvalidArgument,
-               HasSubstr("expected uint value")));
+  EXPECT_THAT(wrapped->Invoke(args, descriptor_pool(), message_factory(),
+                              arena(), nullptr),
+              StatusIs(absl::StatusCode::kInvalidArgument,
+                       HasSubstr("expected uint value")));
 }
 
 TEST_F(FunctionAdapterTest, BinaryFunctionAdapterCreateDescriptorInt) {
@@ -702,8 +706,9 @@ TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction0Args) {
       NullaryFunctionAdapter<absl::StatusOr<Value>>::WrapFunction(
           []() { return StringValue("abc"); });
 
-  ASSERT_OK_AND_ASSIGN(auto result, fn->Invoke({}, descriptor_pool(),
-                                               message_factory(), arena()));
+  ASSERT_OK_AND_ASSIGN(
+      auto result,
+      fn->Invoke({}, descriptor_pool(), message_factory(), arena(), nullptr));
   ASSERT_TRUE(result->Is<StringValue>());
   EXPECT_EQ(result.GetString().ToString(), "abc");
 }
@@ -732,8 +737,9 @@ TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction3Args) {
 
   std::vector<Value> args{IntValue(42), BoolValue(false)};
   args.emplace_back() = StringValue("abcd");
-  ASSERT_OK_AND_ASSIGN(auto result, fn->Invoke(args, descriptor_pool(),
-                                               message_factory(), arena()));
+  ASSERT_OK_AND_ASSIGN(
+      auto result,
+      fn->Invoke(args, descriptor_pool(), message_factory(), arena(), nullptr));
   ASSERT_TRUE(result->Is<StringValue>());
   EXPECT_EQ(result.GetString().ToString(), "42_false_abcd");
 }
@@ -750,9 +756,10 @@ TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction3ArgsBadArgType) {
 
   std::vector<Value> args{IntValue(42), BoolValue(false)};
   args.emplace_back() = TimestampValue(absl::UnixEpoch());
-  EXPECT_THAT(fn->Invoke(args, descriptor_pool(), message_factory(), arena()),
-              StatusIs(absl::StatusCode::kInvalidArgument,
-                       HasSubstr("expected string value")));
+  EXPECT_THAT(
+      fn->Invoke(args, descriptor_pool(), message_factory(), arena(), nullptr),
+      StatusIs(absl::StatusCode::kInvalidArgument,
+               HasSubstr("expected string value")));
 }
 
 TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction3ArgsBadArgCount) {
@@ -766,9 +773,10 @@ TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction3ArgsBadArgCount) {
   });
 
   std::vector<Value> args{IntValue(42), BoolValue(false)};
-  EXPECT_THAT(fn->Invoke(args, descriptor_pool(), message_factory(), arena()),
-              StatusIs(absl::StatusCode::kInvalidArgument,
-                       HasSubstr("unexpected number of arguments")));
+  EXPECT_THAT(
+      fn->Invoke(args, descriptor_pool(), message_factory(), arena(), nullptr),
+      StatusIs(absl::StatusCode::kInvalidArgument,
+               HasSubstr("unexpected number of arguments")));
 }
 
 TEST_F(FunctionAdapterTest, NaryFunctionAdapterCreateDescriptor5Args) {
@@ -801,8 +809,35 @@ TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction5Args) {
   args.emplace_back() = StringValue("abcd");
   args.push_back(IntValue(123));
   args.push_back(IntValue(456));
-  ASSERT_OK_AND_ASSIGN(auto result, fn->Invoke(args, descriptor_pool(),
-                                               message_factory(), arena()));
+  ASSERT_OK_AND_ASSIGN(
+      auto result,
+      fn->Invoke(args, descriptor_pool(), message_factory(), arena(), nullptr));
+  ASSERT_TRUE(result->Is<StringValue>());
+  EXPECT_EQ(result.GetString().ToString(), "42_false_abcd_123_456");
+}
+
+TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction5ArgsWithArena) {
+  std::unique_ptr<Function> fn =
+      NaryFunctionAdapter<absl::StatusOr<Value>, int64_t, bool,
+                          const StringValue&, int64_t, int64_t>::
+          WrapFunction(
+              [](int64_t int_val, bool bool_val, const StringValue& string_val,
+                 int64_t extra_arg, int64_t extra_arg2,
+                 const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+                 google::protobuf::MessageFactory* absl_nonnull message_factory,
+                 google::protobuf::Arena* absl_nonnull arena) -> absl::StatusOr<Value> {
+                return StringValue(absl::StrCat(
+                    int_val, "_", (bool_val ? "true" : "false"), "_",
+                    string_val.ToString(), "_", extra_arg, "_", extra_arg2));
+              });
+
+  std::vector<Value> args{IntValue(42), BoolValue(false)};
+  args.emplace_back() = StringValue("abcd");
+  args.push_back(IntValue(123));
+  args.push_back(IntValue(456));
+  ASSERT_OK_AND_ASSIGN(
+      auto result,
+      fn->Invoke(args, descriptor_pool(), message_factory(), arena(), nullptr));
   ASSERT_TRUE(result->Is<StringValue>());
   EXPECT_EQ(result.GetString().ToString(), "42_false_abcd_123_456");
 }
@@ -824,9 +859,10 @@ TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction5ArgsBadArgType) {
   args.emplace_back() = TimestampValue(absl::UnixEpoch());
   args.push_back(IntValue(123));
   args.push_back(IntValue(456));
-  EXPECT_THAT(fn->Invoke(args, descriptor_pool(), message_factory(), arena()),
-              StatusIs(absl::StatusCode::kInvalidArgument,
-                       HasSubstr("expected string value")));
+  EXPECT_THAT(
+      fn->Invoke(args, descriptor_pool(), message_factory(), arena(), nullptr),
+      StatusIs(absl::StatusCode::kInvalidArgument,
+               HasSubstr("expected string value")));
 }
 
 TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction5ArgsBadArgCount) {
@@ -843,9 +879,10 @@ TEST_F(FunctionAdapterTest, NaryFunctionAdapterWrapFunction5ArgsBadArgCount) {
   });
 
   std::vector<Value> args{IntValue(42), BoolValue(false)};
-  EXPECT_THAT(fn->Invoke(args, descriptor_pool(), message_factory(), arena()),
-              StatusIs(absl::StatusCode::kInvalidArgument,
-                       HasSubstr("unexpected number of arguments")));
+  EXPECT_THAT(
+      fn->Invoke(args, descriptor_pool(), message_factory(), arena(), nullptr),
+      StatusIs(absl::StatusCode::kInvalidArgument,
+               HasSubstr("unexpected number of arguments")));
 }
 
 }  // namespace
diff --git a/runtime/function_registry_test.cc b/runtime/function_registry_test.cc
index 99b5ec406..5d3a5c383 100644
--- a/runtime/function_registry_test.cc
+++ b/runtime/function_registry_test.cc
@@ -54,7 +54,8 @@ class ConstIntFunction : public cel::Function {
       absl::Span<const Value> args,
       const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
       google::protobuf::MessageFactory* absl_nonnull message_factory,
-      google::protobuf::Arena* absl_nonnull arena) const override {
+      google::protobuf::Arena* absl_nonnull arena,
+      const cel::ActivationInterface* absl_nullable activation) const override {
     return IntValue(42);
   }
 };
diff --git a/runtime/optional_types_test.cc b/runtime/optional_types_test.cc
index 1f118b639..2c9bfcec8 100644
--- a/runtime/optional_types_test.cc
+++ b/runtime/optional_types_test.cc
@@ -310,7 +310,8 @@ class UnreachableFunction final : public cel::Function {
       absl::Span<const Value> args,
       const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
       google::protobuf::MessageFactory* absl_nonnull message_factory,
-      google::protobuf::Arena* absl_nonnull arena) const override {
+      google::protobuf::Arena* absl_nonnull arena,
+      const ActivationInterface* absl_nullable) const override {
     ++(*count_);
     return ErrorValue{absl::CancelledError()};
   }
diff --git a/runtime/standard/logical_functions_test.cc b/runtime/standard/logical_functions_test.cc
index de50f5312..ebb108181 100644
--- a/runtime/standard/logical_functions_test.cc
+++ b/runtime/standard/logical_functions_test.cc
@@ -80,7 +80,7 @@ absl::StatusOr<Value> TestDispatchToFunction(
   }
 
   return refs[0].implementation.Invoke(args, descriptor_pool, message_factory,
-                                       arena);
+                                       arena, nullptr);
 }
 
 TEST(RegisterLogicalFunctions, NotStrictlyFalseRegistered) {