Add system prompt section transform support across all SDKs

Add a new 'transform' action for system prompt section customization that
enables read-then-write mutations via callbacks. When a section is configured
with a transform, the runtime sends the current rendered content to the SDK
via a 'systemMessage.transform' JSON-RPC callback, and the SDK dispatches
to per-section user-defined callbacks.

Changes per language:
- TypeScript: SectionTransformFn type, extractTransformCallbacks helper,
  RPC handler, session callback storage
- Python: SectionTransformFn callable type, _extract_transform_callbacks
  helper, RPC handler, session callback storage (sync+async support)
- Go: SectionTransformFn type, Transform field on SectionOverride,
  extractTransformCallbacks helper, RPC handler
- .NET: Transform delegate on SectionOverride, ExtractTransformCallbacks
  helper, RPC handler

Also fixes two pre-existing build errors:
- Go: Casing mismatch in generated_rpc.go (SessionMcp vs SessionMCP)
- .NET: Missing 'url' parameter in Session.LogAsync wrapper

Includes E2E tests and shared snapshot files for all 4 languages.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: MackinnonBuck

dotnet/src/Client.cs

@@ -428,6 +428,11 @@ public async Task<CopilotSession> CreateSessionAsync(SessionConfig config, Cance
         {
             session.On(config.OnEvent);
         }
+        var transformCallbacks = ExtractTransformCallbacks(config.SystemMessage);
+        if (transformCallbacks != null)
+        {
+            session.RegisterTransformCallbacks(transformCallbacks);
+        }
         _sessions[sessionId] = session;
 
         try
@@ -536,6 +541,11 @@ public async Task<CopilotSession> ResumeSessionAsync(string sessionId, ResumeSes
         {
             session.On(config.OnEvent);
         }
+        var transformCallbacks = ExtractTransformCallbacks(config.SystemMessage);
+        if (transformCallbacks != null)
+        {
+            session.RegisterTransformCallbacks(transformCallbacks);
+        }
         _sessions[sessionId] = session;
 
         try
@@ -1222,6 +1232,7 @@ private async Task<Connection> ConnectToServerAsync(Process? cliProcess, string?
         rpc.AddLocalRpcMethod("permission.request", handler.OnPermissionRequestV2);
         rpc.AddLocalRpcMethod("userInput.request", handler.OnUserInputRequest);
         rpc.AddLocalRpcMethod("hooks.invoke", handler.OnHooksInvoke);
+        rpc.AddLocalRpcMethod("systemMessage.transform", handler.OnSystemMessageTransform);
         rpc.StartListening();
 
         // Transition state to Disconnected if the JSON-RPC connection drops
@@ -1271,6 +1282,36 @@ private static JsonSerializerOptions CreateSerializerOptions()
         return _sessions.TryGetValue(sessionId, out var session) ? session : null;
     }
 
+    /// <summary>
+    /// Extracts transform callbacks from section overrides so they can be registered on the session.
+    /// The <see cref="SectionOverride.Transform"/> property is <c>[JsonIgnore]</c> and won't be
+    /// serialized over the wire; this method captures the delegates before the RPC call.
+    /// </summary>
+    private static Dictionary<string, Func<string, Task<string>>>? ExtractTransformCallbacks(SystemMessageConfig? config)
+    {
+        if (config?.Sections == null)
+            return null;
+
+        Dictionary<string, Func<string, Task<string>>>? callbacks = null;
+
+        foreach (var (sectionName, sectionOverride) in config.Sections)
+        {
+            if (sectionOverride.Action == SectionOverrideAction.Transform)
+            {
+                if (sectionOverride.Transform == null)
+                {
+                    throw new ArgumentException(
+                        $"Section '{sectionName}' has action 'Transform' but no Transform callback was provided.");
+                }
+
+                callbacks ??= new Dictionary<string, Func<string, Task<string>>>();
+                callbacks[sectionName] = sectionOverride.Transform;
+            }
+        }
+
+        return callbacks;
+    }
+
     /// <summary>
     /// Disposes the <see cref="CopilotClient"/> synchronously.
     /// </summary>
@@ -1350,6 +1391,13 @@ public async Task<HooksInvokeResponse> OnHooksInvoke(string sessionId, string ho
             return new HooksInvokeResponse(output);
         }
 
+        public async Task<SystemMessageTransformResponse> OnSystemMessageTransform(string sessionId, string sectionName, string content)
+        {
+            var session = client.GetSession(sessionId) ?? throw new ArgumentException($"Unknown session {sessionId}");
+            var result = await session.HandleSystemMessageTransformAsync(sectionName, content);
+            return new SystemMessageTransformResponse(result);
+        }
+
         // Protocol v2 backward-compatibility adapters
 
         public async Task<ToolCallResponseV2> OnToolCallV2(string sessionId,
@@ -1686,6 +1734,7 @@ private static LogLevel MapLevel(TraceEventType eventType)
     [JsonSerializable(typeof(SectionOverride))]
     [JsonSerializable(typeof(SessionMetadata))]
     [JsonSerializable(typeof(SystemMessageConfig))]
+    [JsonSerializable(typeof(SystemMessageTransformResponse))]
     [JsonSerializable(typeof(ToolCallResponseV2))]
     [JsonSerializable(typeof(ToolDefinition))]
     [JsonSerializable(typeof(ToolResultAIContent))]

dotnet/src/Session.cs

@@ -65,6 +65,7 @@ public sealed partial class CopilotSession : IAsyncDisposable
 
     private SessionHooks? _hooks;
     private readonly SemaphoreSlim _hooksLock = new(1, 1);
+    private Dictionary<string, Func<string, Task<string>>>? _transformCallbacks;
     private SessionRpc? _sessionRpc;
     private int _isDisposed;
 
@@ -588,6 +589,31 @@ internal void RegisterHooks(SessionHooks hooks)
         }
     }
 
+    /// <summary>
+    /// Registers transform callbacks for system message sections.
+    /// </summary>
+    /// <param name="callbacks">Dictionary mapping section names to transform functions.</param>
+    internal void RegisterTransformCallbacks(Dictionary<string, Func<string, Task<string>>> callbacks)
+    {
+        _transformCallbacks = callbacks;
+    }
+
+    /// <summary>
+    /// Handles a <c>systemMessage.transform</c> request from the Copilot CLI.
+    /// </summary>
+    /// <param name="sectionName">The section name to transform.</param>
+    /// <param name="content">The current section content.</param>
+    /// <returns>A task that resolves with the transformed content.</returns>
+    internal async Task<string> HandleSystemMessageTransformAsync(string sectionName, string content)
+    {
+        if (_transformCallbacks == null || !_transformCallbacks.TryGetValue(sectionName, out var callback))
+        {
+            throw new InvalidOperationException($"No transform callback registered for section '{sectionName}'");
+        }
+
+        return await callback(content);
+    }
+
     /// <summary>
     /// Handles a hook invocation from the Copilot CLI.
     /// </summary>

dotnet/src/Types.cs

@@ -991,7 +991,10 @@ public enum SectionOverrideAction
     Append,
     /// <summary>Prepend content before the existing section.</summary>
     [JsonStringEnumMemberName("prepend")]
-    Prepend
+    Prepend,
+    /// <summary>Transform the section content via a callback.</summary>
+    [JsonStringEnumMemberName("transform")]
+    Transform
 }
 
 /// <summary>
@@ -1008,6 +1011,13 @@ public class SectionOverride
     /// Content for the override. Optional for all actions. Ignored for remove.
     /// </summary>
     public string? Content { get; set; }
+
+    /// <summary>
+    /// Callback that transforms the section content. Used with <see cref="SectionOverrideAction.Transform"/>.
+    /// This delegate is not serialized; it is registered as an RPC callback.
+    /// </summary>
+    [JsonIgnore]
+    public Func<string, Task<string>>? Transform { get; set; }
 }
 
 /// <summary>
@@ -1060,6 +1070,20 @@ public class SystemMessageConfig
     public Dictionary<string, SectionOverride>? Sections { get; set; }
 }
 
+/// <summary>
+/// RPC request for the <c>systemMessage.transform</c> callback.
+/// </summary>
+internal record SystemMessageTransformRequest(
+    string SessionId,
+    string SectionName,
+    string Content);
+
+/// <summary>
+/// RPC response for the <c>systemMessage.transform</c> callback.
+/// </summary>
+internal record SystemMessageTransformResponse(
+    string Content);
+
 /// <summary>
 /// Configuration for a custom model provider.
 /// </summary>
@@ -2139,6 +2163,8 @@ public class SetForegroundSessionResponse
 [JsonSerializable(typeof(SessionMetadata))]
 [JsonSerializable(typeof(SetForegroundSessionResponse))]
 [JsonSerializable(typeof(SystemMessageConfig))]
+[JsonSerializable(typeof(SystemMessageTransformRequest))]
+[JsonSerializable(typeof(SystemMessageTransformResponse))]
 [JsonSerializable(typeof(ToolBinaryResult))]
 [JsonSerializable(typeof(ToolInvocation))]
 [JsonSerializable(typeof(ToolResultObject))]

dotnet/test/SystemMessageTransformTests.cs

@@ -0,0 +1,139 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+using GitHub.Copilot.SDK.Test.Harness;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace GitHub.Copilot.SDK.Test;
+
+public class SystemMessageTransformTests(E2ETestFixture fixture, ITestOutputHelper output) : E2ETestBase(fixture, "system_message_transform", output)
+{
+    [Fact]
+    public async Task Should_Invoke_Transform_Callbacks_With_Section_Content()
+    {
+        var identityCallbackInvoked = false;
+        var toneCallbackInvoked = false;
+
+        var session = await CreateSessionAsync(new SessionConfig
+        {
+            OnPermissionRequest = PermissionHandler.ApproveAll,
+            SystemMessage = new SystemMessageConfig
+            {
+                Mode = SystemMessageMode.Customize,
+                Sections = new Dictionary<string, SectionOverride>
+                {
+                    ["identity"] = new SectionOverride
+                    {
+                        Transform = async (content) =>
+                        {
+                            Assert.False(string.IsNullOrEmpty(content));
+                            identityCallbackInvoked = true;
+                            return content;
+                        }
+                    },
+                    ["tone"] = new SectionOverride
+                    {
+                        Transform = async (content) =>
+                        {
+                            Assert.False(string.IsNullOrEmpty(content));
+                            toneCallbackInvoked = true;
+                            return content;
+                        }
+                    }
+                }
+            }
+        });
+
+        await File.WriteAllTextAsync(Path.Combine(Ctx.WorkDir, "test.txt"), "Hello transform!");
+
+        await session.SendAsync(new MessageOptions
+        {
+            Prompt = "Read the contents of test.txt and tell me what it says"
+        });
+
+        await TestHelper.GetFinalAssistantMessageAsync(session);
+
+        Assert.True(identityCallbackInvoked, "Expected identity transform callback to be invoked");
+        Assert.True(toneCallbackInvoked, "Expected tone transform callback to be invoked");
+    }
+
+    [Fact]
+    public async Task Should_Apply_Transform_Modifications_To_Section_Content()
+    {
+        var transformCallbackInvoked = false;
+
+        var session = await CreateSessionAsync(new SessionConfig
+        {
+            OnPermissionRequest = PermissionHandler.ApproveAll,
+            SystemMessage = new SystemMessageConfig
+            {
+                Mode = SystemMessageMode.Customize,
+                Sections = new Dictionary<string, SectionOverride>
+                {
+                    ["identity"] = new SectionOverride
+                    {
+                        Transform = async (content) =>
+                        {
+                            transformCallbackInvoked = true;
+                            return content + "TRANSFORM_MARKER";
+                        }
+                    }
+                }
+            }
+        });
+
+        await File.WriteAllTextAsync(Path.Combine(Ctx.WorkDir, "hello.txt"), "Hello!");
+
+        await session.SendAsync(new MessageOptions
+        {
+            Prompt = "Read the contents of hello.txt"
+        });
+
+        await TestHelper.GetFinalAssistantMessageAsync(session);
+
+        Assert.True(transformCallbackInvoked, "Expected identity transform callback to be invoked");
+    }
+
+    [Fact]
+    public async Task Should_Work_With_Static_Overrides_And_Transforms_Together()
+    {
+        var transformCallbackInvoked = false;
+
+        var session = await CreateSessionAsync(new SessionConfig
+        {
+            OnPermissionRequest = PermissionHandler.ApproveAll,
+            SystemMessage = new SystemMessageConfig
+            {
+                Mode = SystemMessageMode.Customize,
+                Sections = new Dictionary<string, SectionOverride>
+                {
+                    ["safety"] = new SectionOverride
+                    {
+                        Action = SectionOverrideAction.Remove
+                    },
+                    ["identity"] = new SectionOverride
+                    {
+                        Transform = async (content) =>
+                        {
+                            transformCallbackInvoked = true;
+                            return content;
+                        }
+                    }
+                }
+            }
+        });
+
+        await File.WriteAllTextAsync(Path.Combine(Ctx.WorkDir, "combo.txt"), "Combo test!");
+
+        await session.SendAsync(new MessageOptions
+        {
+            Prompt = "Read the contents of combo.txt and tell me what it says"
+        });
+
+        await TestHelper.GetFinalAssistantMessageAsync(session);
+
+        Assert.True(transformCallbackInvoked, "Expected identity transform callback to be invoked");
+    }
+}