chore: Fix ldctx silent override and Add Tools to completion config (3 of 6) (#281)

BEGIN_COMMIT_OVERRIDE
feat: Add Tools property to LdAiCompletionConfig — parses the same tools
block agents use, exposes IReadOnlyDictionary<string, ToolConfig> (empty
when absent)
fix: Silently override 'ldctx' in user-supplied template variables
instead of warning and discarding it — the SDK context always wins,
matches cross-SDK behavior
END_COMMIT_OVERRIDE

## Summary

Two tightly-scoped changes to the **Completion** path:

### 1. `Tools` on `LdAiCompletionConfig`

`LdAiCompletionConfig` now exposes `Tools` (an
`IReadOnlyDictionary<string, ToolConfig>`), populated from the `tools`
block on the variation JSON. `ConfigFactory.BuildCompletionConfig` and
`BuildFromDefault` both pass it through; on the default path it's an
empty dictionary.

`tools` is a model-level field rather than an agent-only one, so it now
lives on both completion and agent configs.

### 2. Silent `ldctx` override

`ConfigFactory.MergeVariables` previously warned-and-dropped when a
caller passed an `ldctx` key in their template variables. That diverged
from the other SDKs (python, js-core, ruby) where `ldctx` is silently
overwritten by the LaunchDarkly context. The behavior is now:

- User-supplied variables are seeded first.
- `ldctx` is added last, silently overriding any caller-supplied value.
- No warning is logged. The caller's `ldctx` value never reaches the
Mustache template.

The reserved-key warning is gone; the comment explaining the override is
moved to the line that does it. Practical effect: callers who try to set
`ldctx` explicitly no longer get a confusing "this was ignored" log
line, and the template always sees the real LD context's attributes.

## Migration

`Tools` is additive — no migration needed; existing callers that ignore
it see no change.

The `ldctx` warning change is a **silent behavior change** for any
caller who was previously relying on the warning to spot the
reserved-key collision. If a caller was depending on the warning to flag
an unintended override, they will no longer see it. In practice this
matches what all other SDKs already do.

## Test plan

- [ ] `dotnet build` succeeds across `netstandard2.0`, `net462`,
`net8.0`
- [ ] `dotnet test --framework net8.0` passes
- [ ] `LdAiClientTest.LdCtxOverrideIsSilent` — verifies the SDK
context's `key` wins over a user-supplied `ldctx`, with **no** warning
emitted
- [ ] `LdAiClientTest.ToolsPopulatedOnCompletionConfig` — covers a
`tools` block on a completion config flag, including `customParameters`
- [ ] `LdAiClientTest.ToolsEmptyWhenAbsentFromJson` — covers the
missing-`tools` case, asserting an empty (non-null) dictionary
- [ ] `LdAiConfigTrackerTest` updated to pass `tools` through the new
constructor signature
- [ ] Reviewer confirms the silent-override semantics match python /
js-core / ruby

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Low Risk**
> Additive public API and template-variable behavior aligned with other
SDKs; only callers who relied on the removed `ldctx` warning are
affected.
> 
> **Overview**
> **Completion configs** now surface **`Tools`** (parsed from variation
JSON via shared `ParseTools`, empty when missing) and
**`JudgeConfiguration`** (parsed when present, carried through caller
defaults and `LdAiCompletionConfigDefault` builder/`ToLdValue`
roundtrips).
> 
> **Template variables:** `MergeVariables` no longer logs a warning or
drops a caller-supplied **`ldctx`** key—it seeds user vars first, then
always sets **`ldctx`** from the LaunchDarkly context so Mustache
templates match other SDKs.
> 
> Tests cover silent `ldctx` override, tools presence/absence, judge
config parsing and default fallbacks, and updated `LdAiCompletionConfig`
constructor usage in tracker tests.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
fc3487e. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: mattrmc1

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

@@ -59,13 +59,17 @@ public LdAiCompletionConfig BuildCompletionConfig(
         var model = ParseModel(ldValue.Get("model"));
         var provider = ParseProvider(ldValue.Get("provider"));
         var messages = InterpolateMessages(ParseMessages(ldValue.Get("messages")), mergedVars, key);
+        var tools = ParseTools(ldValue.Get("tools"));
+        var judgeConfiguration = ParseJudgeConfiguration(ldValue.Get("judgeConfiguration"));
 
         return new LdAiCompletionConfig(
             key,
             enabled,
             variationKey,
             version,
             messages,
+            tools,
+            judgeConfiguration,
             model,
             provider,
             trackerFactory);
@@ -86,6 +90,8 @@ private LdAiCompletionConfig BuildCompletionFromDefault(
             variationKey: "",
             version: 1,
             messages,
+            tools: ImmutableDictionary<string, LdAiConfigTypes.Tool>.Empty,
+            defaultValue.JudgeConfiguration,
             defaultValue.Model,
             defaultValue.Provider,
             trackerFactory);
@@ -399,25 +405,18 @@ private static LdAiConfigTypes.Role ParseRole(string roleString)
         return LdAiConfigTypes.Role.User;
     }
 
-    private IReadOnlyDictionary<string, object> MergeVariables(
+    private static IReadOnlyDictionary<string, object> MergeVariables(
         IReadOnlyDictionary<string, object> userVariables, Context context)
     {
-        // Seed with user variables; the special "ldctx" key is reserved for the LaunchDarkly
-        // context and always overrides any user-supplied value of that key.
         var merged = new Dictionary<string, object>();
         if (userVariables != null)
         {
             foreach (var kvp in userVariables)
             {
-                if (kvp.Key == LdContextVariable)
-                {
-                    _logger.Warn(
-                        "AI model config variables contains 'ldctx' key, which is reserved; this key will be the value of the LaunchDarkly context");
-                    continue;
-                }
                 merged[kvp.Key] = kvp.Value;
             }
         }
+        // ldctx is always added last, silently overriding any user-supplied value.
         merged[LdContextVariable] = GetAllAttributes(context);
         return merged;
     }

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

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using LaunchDarkly.Sdk.Server.Ai.Interfaces;
 
@@ -27,11 +28,25 @@ public sealed class LdAiCompletionConfig : LdAiConfig
     /// </summary>
     public IReadOnlyList<LdAiConfigTypes.Message> Messages { get; }
 
+    /// <summary>
+    /// The tools available to the model, keyed by tool name.
+    /// </summary>
+    public IReadOnlyDictionary<string, LdAiConfigTypes.Tool> Tools { get; }
+
+    /// <summary>
+    /// The judge configuration attached to this completion config, or <c>null</c> if none is configured.
+    /// </summary>
+    public LdAiConfigTypes.JudgeConfiguration JudgeConfiguration { get; }
+
     internal LdAiCompletionConfig(string key, bool enabled, string variationKey, int version,
-        IEnumerable<LdAiConfigTypes.Message> messages, LdAiConfigTypes.ModelConfig model, LdAiConfigTypes.ProviderConfig provider,
+        IEnumerable<LdAiConfigTypes.Message> messages, IReadOnlyDictionary<string, LdAiConfigTypes.Tool> tools,
+        LdAiConfigTypes.JudgeConfiguration judgeConfiguration,
+        LdAiConfigTypes.ModelConfig model, LdAiConfigTypes.ProviderConfig provider,
         Func<LdAiConfig, ILdAiConfigTracker> trackerFactory)
         : base(key, enabled, variationKey, version, model, provider, trackerFactory)
     {
         Messages = messages?.ToList() ?? new List<LdAiConfigTypes.Message>();
+        Tools = tools ?? ImmutableDictionary<string, LdAiConfigTypes.Tool>.Empty;
+        JudgeConfiguration = judgeConfiguration;
     }
 }

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

@@ -22,6 +22,7 @@ public class Builder
     {
         private bool _enabled;
         private readonly List<LdAiConfigTypes.Message> _messages;
+        private LdAiConfigTypes.JudgeConfiguration _judgeConfiguration;
         private readonly Dictionary<string, LdValue> _modelParams;
         private readonly Dictionary<string, LdValue> _customModelParams;
         private string _providerName;
@@ -31,6 +32,7 @@ internal Builder()
         {
             _enabled = true;
             _messages = new List<LdAiConfigTypes.Message>();
+            _judgeConfiguration = null;
             _modelParams = new Dictionary<string, LdValue>();
             _customModelParams = new Dictionary<string, LdValue>();
             _providerName = "";
@@ -118,6 +120,17 @@ public Builder SetModelProviderName(string name)
             return this;
         }
 
+        /// <summary>
+        /// Sets the judge configuration for this completion config default.
+        /// </summary>
+        /// <param name="config">the judge configuration</param>
+        /// <returns>a new builder</returns>
+        public Builder SetJudgeConfiguration(LdAiConfigTypes.JudgeConfiguration config)
+        {
+            _judgeConfiguration = config;
+            return this;
+        }
+
         /// <summary>
         /// Builds the LdAiCompletionConfigDefault instance.
         /// </summary>
@@ -129,7 +142,7 @@ public LdAiCompletionConfigDefault Build()
                 new Dictionary<string, LdValue>(_modelParams),
                 new Dictionary<string, LdValue>(_customModelParams));
             var provider = new LdAiConfigTypes.ProviderConfig(_providerName);
-            return new LdAiCompletionConfigDefault(_enabled, _messages, model, provider);
+            return new LdAiCompletionConfigDefault(_enabled, _messages, _judgeConfiguration, model, provider);
         }
     }
 
@@ -138,11 +151,18 @@ public LdAiCompletionConfigDefault Build()
     /// </summary>
     public IReadOnlyList<LdAiConfigTypes.Message> Messages { get; }
 
+    /// <summary>
+    /// The judge configuration for this completion config default, or <c>null</c> if not specified.
+    /// </summary>
+    public LdAiConfigTypes.JudgeConfiguration JudgeConfiguration { get; }
+
     internal LdAiCompletionConfigDefault(bool? enabled, IEnumerable<LdAiConfigTypes.Message> messages,
+        LdAiConfigTypes.JudgeConfiguration judgeConfiguration,
         LdAiConfigTypes.ModelConfig model, LdAiConfigTypes.ProviderConfig provider)
         : base(enabled, model, provider)
     {
         Messages = messages?.ToList() ?? new List<LdAiConfigTypes.Message>();
+        JudgeConfiguration = judgeConfiguration;
     }
 
     internal LdValue ToLdValue()
@@ -153,7 +173,7 @@ internal LdValue ToLdValue()
             ["mode"] = LdValue.Of(LdAiCompletionConfig.Mode)
         };
 
-        return LdValue.ObjectFrom(new Dictionary<string, LdValue>
+        var root = new Dictionary<string, LdValue>
         {
             { "_ldMeta", LdValue.ObjectFrom(metaFields) },
             { "messages", LdValue.ArrayFrom(Messages.Select(m => LdValue.ObjectFrom(new Dictionary<string, LdValue>
@@ -171,7 +191,23 @@ internal LdValue ToLdValue()
             {
                 { "name", LdValue.Of(Provider.Name) }
             }) }
-        });
+        };
+
+        if (JudgeConfiguration != null)
+        {
+            root["judgeConfiguration"] = LdValue.ObjectFrom(new Dictionary<string, LdValue>
+            {
+                { "judges", LdValue.ArrayFrom(JudgeConfiguration.Judges.Select(j =>
+                    LdValue.ObjectFrom(new Dictionary<string, LdValue>
+                    {
+                        { "key", LdValue.Of(j.Key) },
+                        { "samplingRate", LdValue.Of(j.SamplingRate) }
+                    })))
+                }
+            });
+        }
+
+        return LdValue.ObjectFrom(root);
     }
 
     /// <summary>