diff --git a/common/descriptor_pool_type_introspector.cc b/common/descriptor_pool_type_introspector.cc
index fa9ed2a0e..980b2d25d 100644
--- a/common/descriptor_pool_type_introspector.cc
+++ b/common/descriptor_pool_type_introspector.cc
@@ -44,8 +44,7 @@ FindStructTypeFieldByNameDirectly(
   if (descriptor == nullptr) {
     return std::nullopt;
   }
-  const google::protobuf::FieldDescriptor* absl_nullable field =
-      descriptor->FindFieldByName(name);
+  const google::protobuf::FieldDescriptor* field = descriptor->FindFieldByName(name);
   if (field != nullptr) {
     return StructTypeField(MessageTypeField(field));
   }
diff --git a/common/legacy_value.cc b/common/legacy_value.cc
index 7fbf16732..50de9a0f8 100644
--- a/common/legacy_value.cc
+++ b/common/legacy_value.cc
@@ -71,14 +71,15 @@ namespace cel {
 
 namespace {
 
-using google::api::expr::runtime::CelList;
-using google::api::expr::runtime::CelMap;
-using google::api::expr::runtime::CelValue;
-using google::api::expr::runtime::FieldBackedListImpl;
-using google::api::expr::runtime::FieldBackedMapImpl;
-using google::api::expr::runtime::GetGenericProtoTypeInfoInstance;
-using google::api::expr::runtime::LegacyTypeInfoApis;
-using google::api::expr::runtime::MessageWrapper;
+using ::google::api::expr::runtime::CelList;
+using ::google::api::expr::runtime::CelMap;
+using ::google::api::expr::runtime::CelValue;
+using ::google::api::expr::runtime::CreateCelValueFromField;
+using ::google::api::expr::runtime::FieldBackedListImpl;
+using ::google::api::expr::runtime::FieldBackedMapImpl;
+using ::google::api::expr::runtime::GetGenericProtoTypeInfoInstance;
+using ::google::api::expr::runtime::LegacyTypeInfoApis;
+using ::google::api::expr::runtime::MessageWrapper;
 using ::google::api::expr::runtime::internal::MaybeWrapValueToMessage;
 
 absl::Status InvalidMapKeyTypeError(ValueKind kind) {
@@ -1288,6 +1289,36 @@ TypeValue CreateTypeValueFromView(google::protobuf::Arena* arena,
   return TypeValue(common_internal::LegacyRuntimeType(input));
 }
 
+const google::protobuf::Message* absl_nullable GetLegacyMessage(const Value& value) {
+  if (!common_internal::IsLegacyStructValue(value)) {
+    return nullptr;
+  }
+
+  auto legacy = common_internal::GetLegacyStructValue(value);
+  const auto* legacy_type_info = legacy.legacy_type_info();
+  if (legacy_type_info == nullptr) {
+    return nullptr;
+  }
+  if (legacy_type_info != &GetGenericProtoTypeInfoInstance()) {
+    return nullptr;
+  }
+  if (IsWellKnownMessageType(legacy.message_ptr()->GetDescriptor())) {
+    return nullptr;
+  }
+  return legacy.message_ptr();
+}
+
+absl::Status WrapLegacyMessageField(
+    const google::protobuf::Message* absl_nonnull message,
+    const google::protobuf::FieldDescriptor* absl_nonnull field_descriptor,
+    ProtoWrapperTypeOptions unboxing_option, google::protobuf::Arena* arena,
+    Value* absl_nonnull out) {
+  CEL_ASSIGN_OR_RETURN(CelValue result,
+                       CreateCelValueFromField(message, field_descriptor,
+                                               unboxing_option, arena));
+  return ModernValue(arena, result, *out);
+}
+
 }  // namespace interop_internal
 
 }  // namespace cel
diff --git a/common/legacy_value.h b/common/legacy_value.h
index 7e703cea1..8d0392f7a 100644
--- a/common/legacy_value.h
+++ b/common/legacy_value.h
@@ -27,7 +27,9 @@
 #include "common/value.h"
 #include "eval/public/cel_value.h"
 #include "internal/status_macros.h"
+#include "runtime/runtime_options.h"
 #include "google/protobuf/arena.h"
+#include "google/protobuf/descriptor.h"
 
 namespace cel {
 
@@ -59,6 +61,19 @@ google::api::expr::runtime::CelValue UnsafeLegacyValue(
 
 namespace cel::interop_internal {
 
+// Returns the underlying `google::protobuf::Message` of a `cel::Value` if it is a legacy
+// message with the default type info, or `nullptr` otherwise.
+const google::protobuf::Message* absl_nullable GetLegacyMessage(const Value& value);
+
+// Access a field on a legacy message value, writing the result to `out`.
+// Prefers wrapping legacy values instead of using the modern value
+// representation.
+absl::Status WrapLegacyMessageField(
+    const google::protobuf::Message* absl_nonnull message,
+    const google::protobuf::FieldDescriptor* absl_nonnull field_descriptor,
+    ProtoWrapperTypeOptions unboxing_option, google::protobuf::Arena* arena,
+    Value* absl_nonnull out);
+
 absl::StatusOr<Value> FromLegacyValue(
     google::protobuf::Arena* arena,
     const google::api::expr::runtime::CelValue& legacy_value,
diff --git a/common/type.cc b/common/type.cc
index 9ea85954c..2d3469540 100644
--- a/common/type.cc
+++ b/common/type.cc
@@ -606,6 +606,11 @@ absl::optional<MessageTypeField> StructTypeField::AsMessage() const {
   return std::nullopt;
 }
 
+MessageTypeField StructTypeField::GetMessage() const {
+  ABSL_DCHECK(IsMessage());
+  return absl::get<MessageTypeField>(variant_);
+}
+
 StructTypeField::operator MessageTypeField() const {
   ABSL_DCHECK(IsMessage());
   return absl::get<MessageTypeField>(variant_);
diff --git a/common/type.h b/common/type.h
index c8851dd4e..e60452bfd 100644
--- a/common/type.h
+++ b/common/type.h
@@ -1140,6 +1140,7 @@ class StructTypeField final {
   }
 
   absl::optional<MessageTypeField> AsMessage() const;
+  MessageTypeField GetMessage() const;
 
   explicit operator MessageTypeField() const;
 
diff --git a/common/types/message_type.h b/common/types/message_type.h
index 782af87aa..eea811971 100644
--- a/common/types/message_type.h
+++ b/common/types/message_type.h
@@ -87,6 +87,11 @@ class MessageType final {
     return descriptor_;
   }
 
+  const google::protobuf::Descriptor* absl_nonnull descriptor() const {
+    ABSL_DCHECK(*this);
+    return descriptor_;
+  }
+
   explicit operator bool() const { return descriptor_ != nullptr; }
 
  private:
@@ -166,8 +171,12 @@ class MessageTypeField final {
     return *descriptor_;
   }
 
-  const google::protobuf::FieldDescriptor* absl_nonnull operator->() const
-      ABSL_ATTRIBUTE_LIFETIME_BOUND {
+  const google::protobuf::FieldDescriptor* absl_nonnull operator->() const {
+    ABSL_DCHECK(*this);
+    return descriptor_;
+  }
+
+  const google::protobuf::FieldDescriptor* absl_nonnull descriptor() const {
     ABSL_DCHECK(*this);
     return descriptor_;
   }
diff --git a/common/value.cc b/common/value.cc
index f13ee958e..6284626da 100644
--- a/common/value.cc
+++ b/common/value.cc
@@ -17,6 +17,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <memory>
+#include <optional>
 #include <ostream>
 #include <string>
 #include <type_traits>
diff --git a/common/values/parsed_message_value.h b/common/values/parsed_message_value.h
index f3d1f7b40..2e356d3e8 100644
--- a/common/values/parsed_message_value.h
+++ b/common/values/parsed_message_value.h
@@ -99,10 +99,8 @@ class ParsedMessageValue final
     return *value_;
   }
 
-  const google::protobuf::Message* absl_nonnull operator->() const
-      ABSL_ATTRIBUTE_LIFETIME_BOUND {
-    return value_;
-  }
+  const google::protobuf::Message* absl_nonnull operator->() const { return value_; }
+  const google::protobuf::Message* absl_nonnull message() const { return value_; }
 
   bool IsZeroValue() const;
 
@@ -175,6 +173,15 @@ class ParsedMessageValue final
     swap(lhs.arena_, rhs.arena_);
   }
 
+  absl::Status GetField(
+      const google::protobuf::FieldDescriptor* absl_nonnull field,
+      ProtoWrapperTypeOptions unboxing_options,
+      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
+      google::protobuf::MessageFactory* absl_nonnull message_factory,
+      google::protobuf::Arena* absl_nonnull arena, Value* absl_nonnull result) const;
+
+  bool HasField(const google::protobuf::FieldDescriptor* absl_nonnull field) const;
+
  private:
   friend std::pointer_traits<ParsedMessageValue>;
   friend class StructValue;
@@ -203,15 +210,6 @@ class ParsedMessageValue final
     return absl::OkStatus();
   }
 
-  absl::Status GetField(
-      const google::protobuf::FieldDescriptor* absl_nonnull field,
-      ProtoWrapperTypeOptions unboxing_options,
-      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
-      google::protobuf::MessageFactory* absl_nonnull message_factory,
-      google::protobuf::Arena* absl_nonnull arena, Value* absl_nonnull result) const;
-
-  bool HasField(const google::protobuf::FieldDescriptor* absl_nonnull field) const;
-
   const google::protobuf::Message* absl_nonnull value_;
   // Arena that is attributed as owning the value. May be null to indicate that
   // the value is managed externally.
diff --git a/eval/eval/attribute_trail.h b/eval/eval/attribute_trail.h
index 576d0be34..838cc8875 100644
--- a/eval/eval/attribute_trail.h
+++ b/eval/eval/attribute_trail.h
@@ -47,6 +47,7 @@ class AttributeTrail {
 
   // Creates AttributeTrail with attribute path incremented by "qualifier".
   AttributeTrail Step(const std::string* qualifier) const {
+    if (empty()) return AttributeTrail();
     return Step(cel::AttributeQualifier::OfString(*qualifier));
   }
 
diff --git a/eval/public/structs/BUILD b/eval/public/structs/BUILD
index d722559e3..2c7d7ed16 100644
--- a/eval/public/structs/BUILD
+++ b/eval/public/structs/BUILD
@@ -325,6 +325,7 @@ cc_test(
         ":proto_message_type_adapter",
         "//base:attributes",
         "//common:value",
+        "//common:value_testing",
         "//eval/public:cel_value",
         "//eval/public:message_wrapper",
         "//eval/public/containers:container_backed_list_impl",
@@ -365,10 +366,13 @@ cc_test(
     deps = [
         ":legacy_type_info_apis",
         ":protobuf_descriptor_type_provider",
+        "//common:type",
         "//eval/public:cel_value",
         "//eval/public/testing:matchers",
         "//extensions/protobuf:memory_manager",
         "//internal:testing",
+        "@com_google_absl//absl/status:status_matchers",
+        "@com_google_cel_spec//proto/cel/expr/conformance/proto3:test_all_types_cc_proto",
         "@com_google_protobuf//:protobuf",
         "@com_google_protobuf//:wrappers_cc_proto",
     ],
@@ -414,7 +418,9 @@ cc_test(
     deps = [
         ":legacy_type_info_apis",
         ":legacy_type_provider",
+        "//common:type",
         "//internal:testing",
+        "@com_google_absl//absl/status:status_matchers",
         "@com_google_absl//absl/strings:string_view",
     ],
 )
diff --git a/eval/public/structs/legacy_type_info_apis.h b/eval/public/structs/legacy_type_info_apis.h
index 4f07470a1..e470ac566 100644
--- a/eval/public/structs/legacy_type_info_apis.h
+++ b/eval/public/structs/legacy_type_info_apis.h
@@ -61,6 +61,11 @@ class LegacyTypeInfoApis {
   virtual absl::string_view GetTypename(
       const MessageWrapper& wrapped_message) const = 0;
 
+  // Return a pointer to the descriptor for the wrapped message's type.
+  //
+  // Should only be defined for messages with standard behavior (i.e. normal
+  // duck-typed behavior of resolving fields by associated descriptor is
+  // correct).
   virtual const google::protobuf::Descriptor* absl_nullable GetDescriptor(
       const MessageWrapper& wrapped_message [[maybe_unused]]) const {
     return nullptr;
diff --git a/eval/public/structs/legacy_type_provider.cc b/eval/public/structs/legacy_type_provider.cc
index f8db92298..cd7079451 100644
--- a/eval/public/structs/legacy_type_provider.cc
+++ b/eval/public/structs/legacy_type_provider.cc
@@ -16,6 +16,7 @@
 
 #include <cstdint>
 #include <memory>
+#include <optional>
 #include <utility>
 
 #include "absl/base/nullability.h"
@@ -35,6 +36,7 @@
 #include "extensions/protobuf/memory_manager.h"
 #include "internal/status_macros.h"
 #include "google/protobuf/arena.h"
+#include "google/protobuf/descriptor.h"
 #include "google/protobuf/message.h"
 
 namespace google::api::expr::runtime {
@@ -197,22 +199,34 @@ LegacyTypeProvider::FindStructTypeFieldByNameImpl(
       result.has_value()) {
     return result;
   }
-  if (auto type_info = ProvideLegacyTypeInfo(type); type_info.has_value()) {
-    if (auto field_desc = (*type_info)->FindFieldByName(name);
-        field_desc.has_value()) {
-      return cel::common_internal::BasicStructTypeField(
-          field_desc->name, field_desc->number, cel::DynType{});
-    } else {
-      const auto* mutation_apis =
-          (*type_info)->GetMutationApis(MessageWrapper());
-      if (mutation_apis == nullptr || !mutation_apis->DefinesField(name)) {
-        return std::nullopt;
-      }
-      return cel::common_internal::BasicStructTypeField(name, 0,
-                                                        cel::DynType{});
+  absl::optional<const LegacyTypeInfoApis*> type_info =
+      ProvideLegacyTypeInfo(type);
+  if (!type_info.has_value()) {
+    return std::nullopt;
+  }
+  if (const auto* descriptor = (*type_info)->GetDescriptor(MessageWrapper());
+      descriptor != nullptr) {
+    // If it's a normal proto, just use the descriptor to find the field.
+    // Allows us to get the same optimizations as the modern value in most
+    // cases.
+    const google::protobuf::FieldDescriptor* field = descriptor->FindFieldByName(name);
+    if (field != nullptr) {
+      return cel::StructTypeField(cel::MessageTypeField(field));
     }
   }
-  return std::nullopt;
+
+  if (auto field_desc = (*type_info)->FindFieldByName(name);
+      field_desc.has_value()) {
+    return cel::common_internal::BasicStructTypeField(
+        field_desc->name, field_desc->number, cel::DynType{});
+  }
+
+  const auto* mutation_apis = (*type_info)->GetMutationApis(MessageWrapper());
+  if (mutation_apis == nullptr || !mutation_apis->DefinesField(name)) {
+    return std::nullopt;
+  }
+
+  return cel::common_internal::BasicStructTypeField(name, 0, cel::DynType{});
 }
 
 }  // namespace google::api::expr::runtime
diff --git a/eval/public/structs/legacy_type_provider_test.cc b/eval/public/structs/legacy_type_provider_test.cc
index 8de2aba01..2da45e69d 100644
--- a/eval/public/structs/legacy_type_provider_test.cc
+++ b/eval/public/structs/legacy_type_provider_test.cc
@@ -17,13 +17,17 @@
 #include <optional>
 #include <string>
 
+#include "absl/status/status_matchers.h"
 #include "absl/strings/string_view.h"
+#include "common/type.h"
 #include "eval/public/structs/legacy_type_info_apis.h"
 #include "internal/testing.h"
 
 namespace google::api::expr::runtime {
 namespace {
 
+using ::absl_testing::IsOk;
+
 class LegacyTypeProviderTestEmpty : public LegacyTypeProvider {
  public:
   absl::optional<LegacyTypeAdapter> ProvideLegacyType(
@@ -46,6 +50,13 @@ class LegacyTypeInfoApisEmpty : public LegacyTypeInfoApis {
       const MessageWrapper& wrapped_message) const override {
     return nullptr;
   }
+  absl::optional<FieldDescription> FindFieldByName(
+      absl::string_view name) const override {
+    if (name == "field1") {
+      return FieldDescription{1, "field1"};
+    }
+    return absl::nullopt;
+  }
 
  private:
   const std::string test_string_ = "test";
@@ -89,5 +100,22 @@ TEST(LegacyTypeProviderTest, NonEmptyTypeProviderProvidesSomeTypes) {
   EXPECT_EQ(provider.ProvideLegacyTypeInfo("other"), std::nullopt);
 }
 
+TEST(LegacyTypeProviderTest, FindStructTypeFieldByName) {
+  LegacyTypeInfoApisEmpty test_type_info;
+  LegacyTypeProviderTestImpl provider(&test_type_info);
+
+  ASSERT_OK_AND_ASSIGN(absl::optional<cel::StructTypeField> field,
+                       provider.FindStructTypeFieldByName("test", "field1"));
+  ASSERT_TRUE(field.has_value());
+  EXPECT_EQ(field->name(), "field1");
+  EXPECT_EQ(field->number(), 1);
+  EXPECT_EQ(field->GetType(), cel::DynType());
+
+  ASSERT_OK_AND_ASSIGN(
+      absl::optional<cel::StructTypeField> not_found_field,
+      provider.FindStructTypeFieldByName("test", "unknown_field"));
+  EXPECT_FALSE(not_found_field.has_value());
+}
+
 }  // namespace
 }  // namespace google::api::expr::runtime
diff --git a/eval/public/structs/proto_message_type_adapter.cc b/eval/public/structs/proto_message_type_adapter.cc
index 8c140c0c7..a8bb852fc 100644
--- a/eval/public/structs/proto_message_type_adapter.cc
+++ b/eval/public/structs/proto_message_type_adapter.cc
@@ -142,28 +142,6 @@ absl::StatusOr<bool> HasFieldImpl(const google::protobuf::Message* message,
   return CelFieldIsPresent(message, field_desc, reflection);
 }
 
-absl::StatusOr<CelValue> CreateCelValueFromField(
-    const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field_desc,
-    ProtoWrapperTypeOptions unboxing_option, google::protobuf::Arena* arena) {
-  if (field_desc->is_map()) {
-    auto* map = google::protobuf::Arena::Create<internal::FieldBackedMapImpl>(
-        arena, message, field_desc, &MessageCelValueFactory, arena);
-
-    return CelValue::CreateMap(map);
-  }
-  if (field_desc->is_repeated()) {
-    auto* list = google::protobuf::Arena::Create<internal::FieldBackedListImpl>(
-        arena, message, field_desc, &MessageCelValueFactory, arena);
-    return CelValue::CreateList(list);
-  }
-
-  CEL_ASSIGN_OR_RETURN(
-      CelValue result,
-      internal::CreateValueFromSingleField(message, field_desc, unboxing_option,
-                                           &MessageCelValueFactory, arena));
-  return result;
-}
-
 // Shared implementation for GetField.
 // Handles list or map specific behavior before calling reflection helpers.
 absl::StatusOr<CelValue> GetFieldImpl(const google::protobuf::Message* message,
@@ -441,6 +419,28 @@ CelValue MessageCelValueFactory(const google::protobuf::Message* message) {
 
 }  // namespace
 
+absl::StatusOr<CelValue> CreateCelValueFromField(
+    const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field_desc,
+    ProtoWrapperTypeOptions unboxing_option, google::protobuf::Arena* arena) {
+  if (field_desc->is_map()) {
+    auto* map = google::protobuf::Arena::Create<internal::FieldBackedMapImpl>(
+        arena, message, field_desc, &MessageCelValueFactory, arena);
+
+    return CelValue::CreateMap(map);
+  }
+  if (field_desc->is_repeated()) {
+    auto* list = google::protobuf::Arena::Create<internal::FieldBackedListImpl>(
+        arena, message, field_desc, &MessageCelValueFactory, arena);
+    return CelValue::CreateList(list);
+  }
+
+  CEL_ASSIGN_OR_RETURN(
+      CelValue result,
+      internal::CreateValueFromSingleField(message, field_desc, unboxing_option,
+                                           &MessageCelValueFactory, arena));
+  return result;
+}
+
 std::string ProtoMessageTypeAdapter::DebugString(
     const MessageWrapper& wrapped_message) const {
   if (!wrapped_message.HasFullProto() ||
diff --git a/eval/public/structs/proto_message_type_adapter.h b/eval/public/structs/proto_message_type_adapter.h
index f2fc43a8a..eb89a467c 100644
--- a/eval/public/structs/proto_message_type_adapter.h
+++ b/eval/public/structs/proto_message_type_adapter.h
@@ -26,6 +26,7 @@
 #include "eval/public/cel_value.h"
 #include "eval/public/structs/legacy_type_adapter.h"
 #include "eval/public/structs/legacy_type_info_apis.h"
+#include "google/protobuf/arena.h"
 #include "google/protobuf/descriptor.h"
 
 namespace google::api::expr::runtime {
@@ -119,6 +120,13 @@ class ProtoMessageTypeAdapter : public LegacyTypeInfoApis,
   const google::protobuf::Descriptor* descriptor_;
 };
 
+// Creates a CelValue from the given field on the proto message. This is the
+// shared implementation for ProtoMessageTypeAdapter and
+// DucktypedMessageAdapter.
+absl::StatusOr<CelValue> CreateCelValueFromField(
+    const google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field_desc,
+    ProtoWrapperTypeOptions unboxing_option, google::protobuf::Arena* arena);
+
 // Returns a TypeInfo provider representing an arbitrary message.
 // This allows for the legacy duck-typed behavior of messages on field access
 // instead of expecting a particular message type given a TypeInfo.
diff --git a/eval/public/structs/proto_message_type_adapter_test.cc b/eval/public/structs/proto_message_type_adapter_test.cc
index e28d76102..c0e60c632 100644
--- a/eval/public/structs/proto_message_type_adapter_test.cc
+++ b/eval/public/structs/proto_message_type_adapter_test.cc
@@ -20,7 +20,9 @@
 #include "google/protobuf/descriptor.pb.h"
 #include "absl/status/status.h"
 #include "base/attribute.h"
+#include "common/legacy_value.h"
 #include "common/value.h"
+#include "common/value_testing.h"
 #include "eval/public/cel_value.h"
 #include "eval/public/containers/container_backed_list_impl.h"
 #include "eval/public/containers/container_backed_map_impl.h"
@@ -41,6 +43,7 @@
 namespace google::api::expr::runtime {
 namespace {
 
+using ::absl_testing::IsOk;
 using ::absl_testing::IsOkAndHolds;
 using ::absl_testing::StatusIs;
 using ::cel::ProtoWrapperTypeOptions;
@@ -1407,5 +1410,57 @@ TEST(ProtoMesssageTypeAdapter, QualifyMapIndexLeafWrongType) {
                                      HasSubstr("Invalid map key type"))))));
 }
 
+TEST(ProtoMesssageTypeAdapter, InteropUnwrappingNotGeneric) {
+  google::protobuf::Arena arena;
+  ProtoMessageTypeAdapter adapter(
+      google::protobuf::DescriptorPool::generated_pool()->FindMessageTypeByName(
+          "google.api.expr.runtime.TestMessage"),
+      google::protobuf::MessageFactory::generated_factory());
+
+  TestMessage message;
+  message.set_string_value("hello");
+  auto legacy_value = CelValue::CreateMessageWrapper(
+      CelValue::MessageWrapper(&message, &adapter));
+  cel::Value modern_value;
+  ASSERT_THAT(cel::ModernValue(&arena, legacy_value, modern_value), IsOk());
+  auto unwrapped = cel::interop_internal::GetLegacyMessage(modern_value);
+
+  // Can't unwrap a non-generic MessageWrapper -- we test by identity to
+  // be sure we're not dropping a custom adapter.
+  ASSERT_EQ(unwrapped, nullptr);
+}
+
+TEST(ProtoMesssageTypeAdapter, InteropUnwrappingGeneric) {
+  google::protobuf::Arena arena;
+
+  TestMessage message;
+  message.set_string_value("hello");
+  auto legacy_value = CelValue::CreateMessageWrapper(
+      CelValue::MessageWrapper(&message, &GetGenericProtoTypeInfoInstance()));
+  cel::Value modern_value;
+  ASSERT_THAT(cel::ModernValue(&arena, legacy_value, modern_value), IsOk());
+  auto unwrapped = cel::interop_internal::GetLegacyMessage(modern_value);
+
+  ASSERT_EQ(unwrapped, &message);
+}
+
+TEST(ProtoMesssageTypeAdapter, InteropFieldAccess) {
+  google::protobuf::Arena arena;
+
+  TestMessage message;
+  message.set_string_value("hello");
+
+  const google::protobuf::FieldDescriptor* field =
+      message.GetDescriptor()->FindFieldByName("string_value");
+  ASSERT_NE(field, nullptr);
+  cel::Value field_value;
+  ASSERT_THAT(cel::interop_internal::WrapLegacyMessageField(
+                  &message, field, ProtoWrapperTypeOptions::kUnsetNull, &arena,
+                  &field_value),
+              IsOk());
+
+  EXPECT_THAT(field_value, cel::test::StringValueIs("hello"));
+}
+
 }  // namespace
 }  // namespace google::api::expr::runtime
diff --git a/eval/public/structs/protobuf_descriptor_type_provider_test.cc b/eval/public/structs/protobuf_descriptor_type_provider_test.cc
index 3a8fae26b..aabdc38c4 100644
--- a/eval/public/structs/protobuf_descriptor_type_provider_test.cc
+++ b/eval/public/structs/protobuf_descriptor_type_provider_test.cc
@@ -17,16 +17,23 @@
 #include <optional>
 
 #include "google/protobuf/wrappers.pb.h"
+#include "absl/status/status_matchers.h"
+#include "common/type.h"
 #include "eval/public/cel_value.h"
 #include "eval/public/structs/legacy_type_info_apis.h"
 #include "eval/public/testing/matchers.h"
 #include "extensions/protobuf/memory_manager.h"
 #include "internal/testing.h"
+#include "cel/expr/conformance/proto3/test_all_types.pb.h"
 #include "google/protobuf/arena.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/message.h"
 
 namespace google::api::expr::runtime {
 namespace {
 
+using ::absl_testing::IsOk;
+using ::cel::expr::conformance::proto3::TestAllTypes;
 using ::cel::extensions::ProtoMemoryManager;
 
 TEST(ProtobufDescriptorProvider, Basic) {
@@ -36,7 +43,7 @@ TEST(ProtobufDescriptorProvider, Basic) {
   google::protobuf::Arena arena;
   auto manager = ProtoMemoryManager(&arena);
   auto type_adapter = provider.ProvideLegacyType("google.protobuf.Int64Value");
-  absl::optional<const LegacyTypeInfoApis*> type_info =
+  std::optional<const LegacyTypeInfoApis*> type_info =
       provider.ProvideLegacyTypeInfo("google.protobuf.Int64Value");
 
   ASSERT_TRUE(type_adapter.has_value());
@@ -53,8 +60,9 @@ TEST(ProtobufDescriptorProvider, Basic) {
   ASSERT_OK_AND_ASSIGN(CelValue::MessageWrapper::Builder value,
                        type_adapter->mutation_apis()->NewInstance(manager));
 
-  ASSERT_OK(type_adapter->mutation_apis()->SetField(
-      "value", CelValue::CreateInt64(10), manager, value));
+  ASSERT_THAT(type_adapter->mutation_apis()->SetField(
+                  "value", CelValue::CreateInt64(10), manager, value),
+              IsOk());
 
   ASSERT_OK_AND_ASSIGN(
       CelValue adapted,
@@ -91,5 +99,60 @@ TEST(ProtobufDescriptorProvider, NotFound) {
   ASSERT_FALSE(type_info.has_value());
 }
 
+TEST(ProtobufDescriptorProvider, FindType) {
+  ProtobufDescriptorProvider provider(
+      google::protobuf::DescriptorPool::generated_pool(),
+      google::protobuf::MessageFactory::generated_factory());
+  ASSERT_OK_AND_ASSIGN(std::optional<cel::Type> wrapper_type,
+                       provider.FindType("google.protobuf.Int64Value"));
+  ASSERT_TRUE(wrapper_type.has_value());
+  EXPECT_TRUE(wrapper_type->Is<cel::IntWrapperType>());
+  EXPECT_EQ(wrapper_type->name(), "google.protobuf.Int64Value");
+
+  ASSERT_OK_AND_ASSIGN(
+      std::optional<cel::Type> msg_type,
+      provider.FindType("cel.expr.conformance.proto3.TestAllTypes"));
+  ASSERT_TRUE(msg_type.has_value());
+  EXPECT_TRUE(msg_type->Is<cel::MessageType>());
+  EXPECT_EQ(msg_type->name(), "cel.expr.conformance.proto3.TestAllTypes");
+}
+
+TEST(ProtobufDescriptorProvider, FindStructTypeFieldByName) {
+  ProtobufDescriptorProvider provider(
+      google::protobuf::DescriptorPool::generated_pool(),
+      google::protobuf::MessageFactory::generated_factory());
+  ASSERT_OK_AND_ASSIGN(std::optional<cel::StructTypeField> field,
+                       provider.FindStructTypeFieldByName(
+                           "google.protobuf.Int64Value", "value"));
+  ASSERT_TRUE(field.has_value());
+  EXPECT_EQ(field->name(), "value");
+  EXPECT_EQ(field->number(), 1);
+  EXPECT_EQ(field->GetType(), cel::IntType());
+}
+
+TEST(ProtobufDescriptorProvider, FindTypeNotFound) {
+  ProtobufDescriptorProvider provider(
+      google::protobuf::DescriptorPool::generated_pool(),
+      google::protobuf::MessageFactory::generated_factory());
+  ASSERT_OK_AND_ASSIGN(std::optional<cel::Type> type,
+                       provider.FindType("UnknownType"));
+  EXPECT_FALSE(type.has_value());
+}
+
+TEST(ProtobufDescriptorProvider, FindStructTypeFieldByNameNotFound) {
+  ProtobufDescriptorProvider provider(
+      google::protobuf::DescriptorPool::generated_pool(),
+      google::protobuf::MessageFactory::generated_factory());
+  ASSERT_OK_AND_ASSIGN(std::optional<cel::StructTypeField> field,
+                       provider.FindStructTypeFieldByName(
+                           "google.protobuf.Int64Value", "unknown_field"));
+  EXPECT_FALSE(field.has_value());
+
+  ASSERT_OK_AND_ASSIGN(
+      std::optional<cel::StructTypeField> field2,
+      provider.FindStructTypeFieldByName("UnknownType", "value"));
+  EXPECT_FALSE(field2.has_value());
+}
+
 }  // namespace
 }  // namespace google::api::expr::runtime
diff --git a/runtime/internal/BUILD b/runtime/internal/BUILD
index 1223ff6d1..f1141ef08 100644
--- a/runtime/internal/BUILD
+++ b/runtime/internal/BUILD
@@ -174,6 +174,7 @@ cc_library(
         "//internal:testing_message_factory",
         "@com_google_absl//absl/base:nullability",
         "@com_google_absl//absl/log:absl_check",
+        "@com_google_absl//absl/log:die_if_null",
         "@com_google_protobuf//:protobuf",
     ],
 )
diff --git a/runtime/internal/runtime_env_testing.h b/runtime/internal/runtime_env_testing.h
index 71b2096cd..8c391784d 100644
--- a/runtime/internal/runtime_env_testing.h
+++ b/runtime/internal/runtime_env_testing.h
@@ -18,12 +18,43 @@
 #include <memory>
 
 #include "absl/base/nullability.h"
+#include "absl/log/absl_check.h"
+#include "absl/log/die_if_null.h"
+#include "internal/testing_descriptor_pool.h"
+#include "internal/testing_message_factory.h"
 #include "runtime/internal/runtime_env.h"
+#include "google/protobuf/arena.h"
+#include "google/protobuf/descriptor.h"
+#include "google/protobuf/message.h"
 
 namespace cel::runtime_internal {
 
 absl_nonnull std::shared_ptr<RuntimeEnv> NewTestingRuntimeEnv();
 
+template <typename T>
+const google::protobuf::Descriptor* absl_nonnull GetTestingEnvDescriptor() {
+  const google::protobuf::Descriptor* descriptor =
+      internal::GetTestingDescriptorPool()->FindMessageTypeByName(
+          T::descriptor()->full_name());
+  ABSL_CHECK(descriptor != nullptr)
+      << "Could not find CEL test env descriptor for type "
+      << T::descriptor()->full_name();
+  return descriptor;
+}
+
+template <typename T>
+google::protobuf::Message* absl_nonnull MakeTestingEnvDynamicProto(
+    const T& in, google::protobuf::Arena* absl_nonnull arena) {
+  const google::protobuf::Descriptor* descriptor = GetTestingEnvDescriptor<T>();
+  google::protobuf::Message* out =
+      ABSL_DIE_IF_NULL(
+          internal::GetTestingMessageFactory()->GetPrototype(descriptor))
+          ->New(arena);
+
+  ABSL_CHECK(out->MergeFromString(in.SerializeAsString()));
+  return out;
+}
+
 }  // namespace cel::runtime_internal
 
 #endif  // THIRD_PARTY_CEL_CPP_RUNTIME_INTERNAL_RUNTIME_ENV_TESTING_H_