pass LdValue as default value

Author: cwaldren-ld

pkgs/sdk/server-ai/src/Config/LdAiConfig.cs

@@ -126,6 +126,49 @@ internal LdAiConfig(bool enabled, IEnumerable<Message> prompt, Meta meta, IReadO
         Enabled = enabled;
     }
 
+    private static LdValue ObjectToValue(object obj)
+    {
+        if (obj == null)
+        {
+            return LdValue.Null;
+        }
+
+        return obj switch
+        {
+            bool b => LdValue.Of(b),
+            double d => LdValue.Of(d),
+            string s => LdValue.Of(s),
+            IEnumerable<object> list => LdValue.ArrayFrom(list.Select(ObjectToValue)),
+            IDictionary<string, object> dict => LdValue.ObjectFrom(dict.ToDictionary(kv => kv.Key,
+                kv => ObjectToValue(kv.Value))),
+            _ => LdValue.Null
+        };
+    }
+
+    /// <summary>
+    /// Converts the AI config to a compatible LdValue representation.
+    /// Used internally.
+    /// </summary>
+    /// <returns>an LdValue</returns>
+    public LdValue ToLdValue()
+    {
+        return LdValue.ObjectFrom(new Dictionary<string, LdValue>
+        {
+            { "_ldMeta", LdValue.ObjectFrom(
+                new Dictionary<string, LdValue>
+                {
+                    { "versionKey", LdValue.Of(VersionKey) },
+                    { "enabled", LdValue.Of(Enabled) }
+                }) },
+            { "prompt", LdValue.ArrayFrom(Prompt.Select(m => LdValue.ObjectFrom(new Dictionary<string, LdValue>
+            {
+                { "content", LdValue.Of(m.Content) },
+                { "role", LdValue.Of(m.Role.ToString()) }
+            }))) },
+            { "model", ObjectToValue(Model) }
+        });
+    }
+
 
     /// <summary>
     /// Creates a new LdAiConfig builder.

pkgs/sdk/server-ai/src/LdAiClient.cs

@@ -47,22 +47,14 @@ public ILdAiConfigTracker ModelConfig(string key, Context context, LdAiConfig de
         IReadOnlyDictionary<string, object> variables = null)
     {
 
-        var result = _client.JsonVariation(key, context, LdValue.Null);
-
-        var defaultTracker = new LdAiConfigTracker(_client, key, defaultValue, context);
-
-        if (result.IsNull)
-        {
-            _logger.Warn("Unable to retrieve AI model config for {0}, returning default config", key);
-            return defaultTracker;
-        }
-
+        var defaultValVal = defaultValue.ToLdValue();
+        var result = _client.JsonVariation(key, context, defaultValVal);
 
         var parsed = ParseConfig(result, key);
         if (parsed == null)
         {
             // ParseConfig already does logging.
-            return defaultTracker;
+            return new LdAiConfigTracker(_client, key, defaultValue, context);
         }
 
 
@@ -129,7 +121,6 @@ private static object ValueToObject(LdValue value)
         };
     }
 
-
     private static string InterpolateTemplate(string template, IReadOnlyDictionary<string, object> variables)
     {
         return Template.Compile(template).Render(variables);

pkgs/sdk/server-ai/test/InterpolationTests.cs

@@ -16,37 +16,23 @@ private string Eval(string prompt, Context context, IReadOnlyDictionary<string,
         var mockClient = new Mock<ILaunchDarklyClient>();
         var mockLogger = new Mock<ILogger>();
 
-        var config = new AiConfig
-        {
-            Meta = new Meta
-            {
-                Enabled = true,
-                VersionKey = "1"
-            },
-            Model = null,
-            Prompt = new List<Message>
-            {
-                new()
-                {
-                    Content = prompt,
-                    Role = Role.System
-                }
-            }
-        };
 
-        var options = new JsonSerializerOptions
-        {
-            WriteIndented = true,
-            Converters =
-            {
-                new JsonStringEnumConverter(JsonNamingPolicy.CamelCase)
-            }
-        };
+        var configJson = """
+                        {
+                            "_ldMeta": {"versionKey": "1", "enabled": true},
+                            "model": {},
+                            "prompt": [
+                                {
+                                    "content": "<prompt>",
+                                    "role": "System"
+                                }
+                            ]
+                        }
+                        """.Replace("<prompt>", prompt);
 
-        var json = JsonSerializer.Serialize(config, options);
 
         mockClient.Setup(x =>
-            x.JsonVariation("foo", It.IsAny<Context>(), LdValue.Null)).Returns(LdValue.Parse(json));
+            x.JsonVariation("foo", It.IsAny<Context>(), It.IsAny<LdValue>())).Returns(LdValue.Parse(configJson));
 
         mockClient.Setup(x => x.GetLogger()).Returns(mockLogger.Object);
 

pkgs/sdk/server-ai/test/LdAiClientTest.cs

@@ -17,7 +17,7 @@ public void CanInstantiateWithServerSideClient()
         var client = new LdClientAdapter(new LdClient(Configuration.Builder("key").Offline(true).Build()));
         var aiClient = new LdAiClient(client);
         var result= aiClient.ModelConfig("foo", Context.New("key"), LdAiConfig.Disabled);
-        Assert.Equal(LdAiConfig.Disabled, result.Config);
+        Assert.False(result.Config.Enabled);
     }
 
     [Fact]
@@ -27,14 +27,14 @@ public void ThrowsIfClientIsNull()
     }
 
     [Fact]
-    public void ReturnsDefaultConfigWhenFlagNotFound()
+    public void ReturnsDefaultConfigWhenGivenInvalidVariation()
     {
         var mockClient = new Mock<ILaunchDarklyClient>();
 
         var mockLogger = new Mock<ILogger>();
 
         mockClient.Setup(x =>
-            x.JsonVariation("foo", It.IsAny<Context>(), LdValue.Null)).Returns(LdValue.Null);
+            x.JsonVariation("foo", It.IsAny<Context>(), It.IsAny<LdValue>())).Returns(LdValue.Null);
 
 
         mockClient.Setup(x => x.GetLogger()).Returns(mockLogger.Object);
@@ -86,14 +86,14 @@ public void ConfigNotEnabledReturnsDisabledInstance(string json)
         var mockLogger = new Mock<ILogger>();
 
         mockClient.Setup(x =>
-            x.JsonVariation("foo", It.IsAny<Context>(), LdValue.Null)).Returns(LdValue.Parse(json));
+            x.JsonVariation("foo", It.IsAny<Context>(), It.IsAny<LdValue>())).Returns(LdValue.Parse(json));
 
         mockClient.Setup(x => x.GetLogger()).Returns(mockLogger.Object);
 
         var client = new LdAiClient(mockClient.Object);
 
         // All the JSON inputs here are considered disabled, either due to lack of the 'enabled' property,
-        // or if present, it is set to false. Therefore if the default was returned, we'd see the assertion fail
+        // or if present, it is set to false. Therefore, if the default was returned, we'd see the assertion fail
         // (since calling LdAiConfig.New() constructs an enabled config by default.)
         var tracker = client.ModelConfig("foo", Context.New(ContextKind.Default, "key"),
             LdAiConfig.New().AddPromptMessage("foo").Build());
@@ -117,7 +117,7 @@ public void ConfigEnabledReturnsInstance()
                             """;
 
         mockClient.Setup(x =>
-            x.JsonVariation("foo", It.IsAny<Context>(), LdValue.Null)).Returns(LdValue.Parse(json));
+            x.JsonVariation("foo", It.IsAny<Context>(), It.IsAny<LdValue>())).Returns(LdValue.Parse(json));
 
         mockClient.Setup(x => x.GetLogger()).Returns(mockLogger.Object);