refactor: encode LDContext into ldctx map directly (AIC-2695)

Build the ldctx template variable by walking the LDContext's attributes
directly instead of serializing it to a JSON string and parsing it back
into an LDValue. This removes the serialize-then-deserialize round trip
flagged in review, following the generic-encoder shape used by the iOS
SDK. Custom attribute values are still converted via LDValueConverter so
nested objects/arrays remain addressable, and multi-kind contexts are
exposed as {"kind":"multi", <kind>: {...}}.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: ctawiah

lib/sdk/server-ai/src/main/java/com/launchdarkly/sdk/server/ai/internal/Interpolator.java

@@ -1,8 +1,6 @@
 package com.launchdarkly.sdk.server.ai.internal;
 
 import com.launchdarkly.sdk.LDContext;
-import com.launchdarkly.sdk.LDValue;
-import com.launchdarkly.sdk.json.JsonSerialization;
 import com.launchdarkly.sdk.server.ai.internal.mustache.Mustache;
 import com.launchdarkly.sdk.server.ai.internal.mustache.Template;
 
@@ -86,12 +84,46 @@ private String render(String template, Map<String, Object> variables) {
     return compiled.execute(variables);
   }
 
+  /**
+   * Encodes the evaluation context directly into the nested map structure exposed to templates as
+   * {@code ldctx}, without round-tripping through JSON serialization. A single-kind context becomes
+   * a map of its attributes; a multi-kind context becomes {@code {"kind":"multi", <kind>: {...}}}
+   * with one nested map per individual context.
+   */
   private static Map<String, Object> contextToMap(LDContext context) {
     if (context == null || !context.isValid()) {
       return new HashMap<>();
     }
-    LDValue asValue = LDValue.parse(JsonSerialization.serialize(context));
-    Map<String, Object> map = LDValueConverter.toMap(asValue);
-    return map == null ? new HashMap<String, Object>() : map;
+    if (context.isMultiple()) {
+      Map<String, Object> map = new HashMap<>();
+      map.put("kind", "multi");
+      int count = context.getIndividualContextCount();
+      for (int i = 0; i < count; i++) {
+        LDContext individual = context.getIndividualContext(i);
+        if (individual != null) {
+          map.put(individual.getKind().toString(), singleContextToMap(individual));
+        }
+      }
+      return map;
+    }
+    return singleContextToMap(context);
+  }
+
+  private static Map<String, Object> singleContextToMap(LDContext context) {
+    Map<String, Object> map = new HashMap<>();
+    map.put("kind", context.getKind().toString());
+    map.put("key", context.getKey());
+    if (context.getName() != null) {
+      map.put("name", context.getName());
+    }
+    if (context.isAnonymous()) {
+      map.put("anonymous", true);
+    }
+    // Custom attribute values can be arbitrary JSON; convert each LDValue to a plain Java value
+    // (depth-capped) so nested objects/arrays remain addressable from templates.
+    for (String attribute : context.getCustomAttributeNames()) {
+      map.put(attribute, LDValueConverter.toJavaObject(context.getValue(attribute)));
+    }
+    return map;
   }
 }

lib/sdk/server-ai/src/test/java/com/launchdarkly/sdk/server/ai/internal/InterpolatorTest.java

@@ -67,6 +67,24 @@ public void exposesContextAsLdctx() {
     assertThat(result, is("user/user-key/Bob/gold"));
   }
 
+  @Test
+  public void exposesNestedCustomAttribute() {
+    LDContext context = LDContext.builder("user-key")
+        .set("address", com.launchdarkly.sdk.LDValue.buildObject().put("city", "Oakland").build())
+        .build();
+    assertThat(interpolator.interpolate("{{ldctx.address.city}}", null, context), is("Oakland"));
+  }
+
+  @Test
+  public void exposesMultiKindContextByKind() {
+    LDContext multi = LDContext.createMulti(
+        LDContext.builder("user-key").name("Bob").build(),
+        LDContext.builder(com.launchdarkly.sdk.ContextKind.of("org"), "org-key").set("tier", "gold").build());
+    String result = interpolator.interpolate(
+        "{{ldctx.kind}}/{{ldctx.user.key}}/{{ldctx.user.name}}/{{ldctx.org.tier}}", null, multi);
+    assertThat(result, is("multi/user-key/Bob/gold"));
+  }
+
   @Test
   public void ldctxOverridesUserSuppliedValue() {
     Map<String, Object> userLdctx = new HashMap<>();