SDK: add optional memory configuration to session create and resume (#1617)

* Add optional memory configuration to session create and resume

Add a `MemoryConfiguration` type and a `memory` option on `SessionConfig`
and `ResumeSessionConfig`, with `with_memory` builders. The configuration
serializes as an optional `memory` object on the `session.create` /
`session.resume` requests and is omitted when unset, so the runtime applies
its own default for the memory feature.

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

* Trim memory runtime-default note to the type doc

Keep the runtime-default note only on the MemoryConfiguration type
comment; drop it from the field and builder docs. In the README, drop
the runtime-default note (no sibling feature section mentions runtime
defaults), fix the trailing colon so the code block reads as a usage
example, and remove the extensibility aside.

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

* Drop usage example from with_memory doc comment

No other SessionConfig / ResumeSessionConfig builder method carries a
usage-example doctest; keep with_memory consistent with its siblings.
The README retains a usage example.

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

* Remove Default derive from MemoryConfiguration

MemoryConfiguration exposes explicit enabled()/disabled() constructors, so a
Default impl is redundant. SessionConfig and ResumeSessionConfig hold memory as
Option<MemoryConfiguration>, which defaults to None without requiring
MemoryConfiguration: Default.

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

* Add memory configuration API to Go, Node, Python, .NET, and Java SDKs

Mirror the Rust session memory surface across the remaining SDK
languages: session create and resume accept an optional memory
configuration carrying a required `enabled` flag, omitted from the
wire when unset. Adds the type, the create/resume wiring, clone and
serialization coverage, and README docs per language.

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

* Default session memory to disabled in empty client mode

Apply the empty-mode SDK default for the `memory` session option across all
language SDKs: in `empty` client mode `memory` defaults to disabled unless the
app supplies a value, while in the default `copilot-cli` mode `memory` is left
unset so the runtime applies its own default. Caller-supplied configuration
always wins. Adds unit tests (Rust, Go, Node, Python) and a README note per
language.

Also break a module-level cyclic import in the Python client by importing
`MemoryConfiguration` under `TYPE_CHECKING` (it is only referenced in
annotations, which are lazy via `from __future__ import annotations`).

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

* Test: avoid deprecated buildCreateRequest signature in java tests

* Fix python cyclic imports for CodeQL

* Address review comments on SDK PR 1617

- Fix Python payload keys for ModelCapabilitiesOverride serialization to match wire format (camelCase instead of snake_case)
- Update Rust README example to include SessionConfig import

* Re-trigger CI for flaky Windows model-switch e2e

The Node.js SDK Tests (windows-latest) leg failed on an unrelated, flaky
end-to-end test (test/e2e/rpc_session_state.e2e.test.ts, model switchTo:
expected claude-sonnet-4.5, received gpt-4.1). This PR only changes the
memory configuration RPC surface and does not touch model switching or
session-state code. The same base commit (Update @github/copilot to 1.0.62)
passes this leg on main.

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

* Tighten _memory_default typing to MemoryConfiguration

Type _memory_default's supplied parameter and return value as
MemoryConfiguration | None instead of Any, matching the type specificity of
the other mode-default helpers and recovering the benefit of the
MemoryConfiguration TypedDict. The type is imported under TYPE_CHECKING (with
the module's existing 'from __future__ import annotations') so no runtime
import edge is added between _mode and session.

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

---------

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

Author: Morabbin

dotnet/README.md

@@ -410,6 +410,20 @@ When enabled, sessions emit compaction events:
 - `SessionCompactionStartEvent` - Background compaction started
 - `SessionCompactionCompleteEvent` - Compaction finished (includes token counts)
 
+## Memory
+
+Sessions can opt into persistent memory, allowing the agent to read and write memory across turns. Memory is configured per session and applies to both `CreateSessionAsync` and `ResumeSessionAsync`.
+
+```csharp
+var session = await client.CreateSessionAsync(new SessionConfig
+{
+    Model = "gpt-5",
+    Memory = new MemoryConfiguration { Enabled = true }
+});
+```
+
+When `Memory` is left unset, no memory configuration is sent and the runtime default applies. In the default `CopilotClientMode.CopilotCli` the SDK leaves `Memory` unset so the runtime applies its own default, while `CopilotClientMode.Empty` defaults `Memory` to disabled unless you set it explicitly.
+
 ## Advanced Usage
 
 ### Manual Server Control

dotnet/src/Client.cs

@@ -672,6 +672,7 @@ private void ApplyConfigDefaultsForMode(SessionConfigBase config)
             config.EnableHostGitOperations ??= false;
             config.EnableSessionStore ??= false;
             config.EnableSkills ??= false;
+            config.Memory ??= new MemoryConfiguration { Enabled = false };
             config.McpOAuthTokenStorage ??= McpOAuthTokenStorageMode.InMemory;
         }
     }
@@ -935,6 +936,7 @@ public async Task<CopilotSession> CreateSessionAsync(SessionConfig config, Cance
                 InstructionDirectories: config.InstructionDirectories,
                 PluginDirectories: config.PluginDirectories,
                 LargeOutput: config.LargeOutput,
+                Memory: config.Memory,
                 Canvases: config.Canvases,
                 RequestCanvasRenderer: config.RequestCanvasRenderer,
                 RequestExtensions: config.RequestExtensions,
@@ -1131,6 +1133,7 @@ public async Task<CopilotSession> ResumeSessionAsync(string sessionId, ResumeSes
                 InstructionDirectories: config.InstructionDirectories,
                 PluginDirectories: config.PluginDirectories,
                 LargeOutput: config.LargeOutput,
+                Memory: config.Memory,
                 Canvases: config.Canvases,
                 RequestCanvasRenderer: config.RequestCanvasRenderer,
                 RequestExtensions: config.RequestExtensions,
@@ -2322,6 +2325,7 @@ internal record CreateSessionRequest(
         IList<string>? InstructionDirectories = null,
         IList<string>? PluginDirectories = null,
         LargeToolOutputConfig? LargeOutput = null,
+        MemoryConfiguration? Memory = null,
 #pragma warning disable GHCP001
         IList<CanvasDeclaration>? Canvases = null,
         bool? RequestCanvasRenderer = null,
@@ -2412,6 +2416,7 @@ internal record ResumeSessionRequest(
         IList<string>? InstructionDirectories = null,
         IList<string>? PluginDirectories = null,
         LargeToolOutputConfig? LargeOutput = null,
+        MemoryConfiguration? Memory = null,
 #pragma warning disable GHCP001
         IList<CanvasDeclaration>? Canvases = null,
         bool? RequestCanvasRenderer = null,

dotnet/src/Types.cs

@@ -2364,6 +2364,18 @@ public sealed class LargeToolOutputConfig
     public string? OutputDirectory { get; set; }
 }
 
+/// <summary>
+/// Configuration for session memory.
+/// </summary>
+public sealed class MemoryConfiguration
+{
+    /// <summary>
+    /// Whether memory is enabled for the session.
+    /// </summary>
+    [JsonPropertyName("enabled")]
+    public bool Enabled { get; set; }
+}
+
 /// <summary>
 /// GitHub repository metadata to associate with a cloud session.
 /// </summary>
@@ -2458,6 +2470,7 @@ protected SessionConfigBase(SessionConfigBase? other)
         Hooks = other.Hooks;
         InfiniteSessions = other.InfiniteSessions;
         LargeOutput = other.LargeOutput;
+        Memory = other.Memory;
         McpServers = other.McpServers is not null
             ? (other.McpServers is Dictionary<string, McpServerConfig> dict
                 ? new Dictionary<string, McpServerConfig>(dict, dict.Comparer)
@@ -2805,6 +2818,12 @@ protected SessionConfigBase(SessionConfigBase? other)
     /// </summary>
     public LargeToolOutputConfig? LargeOutput { get; set; }
 
+    /// <summary>
+    /// Configuration for session memory. When set, controls whether the
+    /// session can read and write persistent memory.
+    /// </summary>
+    public MemoryConfiguration? Memory { get; set; }
+
     /// <summary>
     /// Optional event handler registered on the session before the session.create / session.resume
     /// RPC is issued, ensuring early events are delivered.

dotnet/test/Unit/CloneTests.cs

@@ -97,6 +97,7 @@ public void SessionConfig_Clone_CopiesAllProperties()
             DisabledSkills = ["skill1"],
             PluginDirectories = ["/plugins"],
             LargeOutput = new LargeToolOutputConfig { Enabled = true, MaxSizeBytes = 2048, OutputDirectory = "/tmp/out" },
+            Memory = new MemoryConfiguration { Enabled = true },
             OnExitPlanModeRequest = static (_, _) => Task.FromResult(new ExitPlanModeResult()),
             OnAutoModeSwitchRequest = static (_, _) => Task.FromResult(AutoModeSwitchResponse.No),
         };
@@ -129,6 +130,7 @@ public void SessionConfig_Clone_CopiesAllProperties()
         Assert.Equal(original.DisabledSkills, clone.DisabledSkills);
         Assert.Equal(original.PluginDirectories, clone.PluginDirectories);
         Assert.Same(original.LargeOutput, clone.LargeOutput);
+        Assert.Same(original.Memory, clone.Memory);
         Assert.Same(original.OnExitPlanModeRequest, clone.OnExitPlanModeRequest);
         Assert.Same(original.OnAutoModeSwitchRequest, clone.OnAutoModeSwitchRequest);
     }
@@ -402,12 +404,14 @@ public void ResumeSessionConfig_Clone_CopiesPluginDirectoriesAndLargeOutput()
         {
             PluginDirectories = ["/resume/plugins"],
             LargeOutput = largeOutput,
+            Memory = new MemoryConfiguration { Enabled = true },
         };
 
         var clone = original.Clone();
 
         Assert.Equal(original.PluginDirectories, clone.PluginDirectories);
         Assert.Same(original.LargeOutput, clone.LargeOutput);
+        Assert.Same(original.Memory, clone.Memory);
     }
 
     [Fact]

dotnet/test/Unit/SerializationTests.cs

@@ -267,6 +267,58 @@ public void SessionRequests_CanSerializePluginDirectoriesAndLargeOutput_WithSdkO
         Assert.Equal("/tmp/large-output", resumeLargeOutput.GetProperty("outputDir").GetString());
     }
 
+    [Fact]
+    public void SessionRequests_CanSerializeMemory_WithSdkOptions()
+    {
+        var options = GetSerializerOptions();
+
+        var createRequestType = GetNestedType(typeof(CopilotClient), "CreateSessionRequest");
+        var createRequest = CreateInternalRequest(
+            createRequestType,
+            ("SessionId", "session-id"),
+            ("Memory", new MemoryConfiguration { Enabled = true }));
+
+        var createJson = JsonSerializer.Serialize(createRequest, createRequestType, options);
+        using var createDocument = JsonDocument.Parse(createJson);
+        var createRoot = createDocument.RootElement;
+        Assert.True(createRoot.GetProperty("memory").GetProperty("enabled").GetBoolean());
+
+        var resumeRequestType = GetNestedType(typeof(CopilotClient), "ResumeSessionRequest");
+        var resumeRequest = CreateInternalRequest(
+            resumeRequestType,
+            ("SessionId", "session-id"),
+            ("Memory", new MemoryConfiguration { Enabled = false }));
+
+        var resumeJson = JsonSerializer.Serialize(resumeRequest, resumeRequestType, options);
+        using var resumeDocument = JsonDocument.Parse(resumeJson);
+        var resumeRoot = resumeDocument.RootElement;
+        Assert.False(resumeRoot.GetProperty("memory").GetProperty("enabled").GetBoolean());
+    }
+
+    [Fact]
+    public void SessionRequests_OmitMemory_WhenUnset()
+    {
+        var options = GetSerializerOptions();
+
+        var createRequestType = GetNestedType(typeof(CopilotClient), "CreateSessionRequest");
+        var createRequest = CreateInternalRequest(
+            createRequestType,
+            ("SessionId", "session-id"));
+
+        var createJson = JsonSerializer.Serialize(createRequest, createRequestType, options);
+        using var createDocument = JsonDocument.Parse(createJson);
+        Assert.False(createDocument.RootElement.TryGetProperty("memory", out _));
+
+        var resumeRequestType = GetNestedType(typeof(CopilotClient), "ResumeSessionRequest");
+        var resumeRequest = CreateInternalRequest(
+            resumeRequestType,
+            ("SessionId", "session-id"));
+
+        var resumeJson = JsonSerializer.Serialize(resumeRequest, resumeRequestType, options);
+        using var resumeDocument = JsonDocument.Parse(resumeJson);
+        Assert.False(resumeDocument.RootElement.TryGetProperty("memory", out _));
+    }
+
     [Fact]
     public void CreateSessionRequest_CanSerializeEnableSessionTelemetry_WithSdkOptions()
     {

go/README.md

@@ -497,6 +497,32 @@ When enabled, sessions emit compaction events:
 - `session.compaction_start` - Background compaction started
 - `session.compaction_complete` - Compaction finished (includes token counts)
 
+## Memory
+
+Sessions can opt in to the memory feature, which lets the agent persist and recall
+information across turns. Provide a `MemoryConfiguration` on session create or resume;
+when omitted, the runtime default applies. In the default `ModeCopilotCli` client mode the
+SDK leaves `Memory` unset so the runtime applies its own default, while `ModeEmpty`
+defaults `Memory` to disabled unless you set it explicitly.
+
+```go
+// Enable memory for a session
+session, _ := client.CreateSession(context.Background(), &copilot.SessionConfig{
+    Model: "gpt-5",
+    Memory: &copilot.MemoryConfiguration{
+        Enabled: true,
+    },
+})
+
+// Disable memory for a session
+session, _ := client.CreateSession(context.Background(), &copilot.SessionConfig{
+    Model: "gpt-5",
+    Memory: &copilot.MemoryConfiguration{
+        Enabled: false,
+    },
+})
+```
+
 ## Custom Providers
 
 The SDK supports custom OpenAI-compatible API providers (BYOK - Bring Your Own Key), including local providers like Ollama. When using a custom provider, you must specify the `Model` explicitly.

go/client.go

@@ -647,6 +647,7 @@ func (c *Client) CreateSession(ctx context.Context, config *SessionConfig) (*Ses
 	req.DisabledSkills = config.DisabledSkills
 	req.InfiniteSessions = config.InfiniteSessions
 	req.LargeOutput = config.LargeOutput
+	req.Memory = config.Memory
 	req.GitHubToken = config.GitHubToken
 	req.RemoteSession = config.RemoteSession
 	req.Cloud = config.Cloud
@@ -983,6 +984,7 @@ func (c *Client) ResumeSessionWithOptions(ctx context.Context, sessionID string,
 	req.DisabledSkills = config.DisabledSkills
 	req.InfiniteSessions = config.InfiniteSessions
 	req.LargeOutput = config.LargeOutput
+	req.Memory = config.Memory
 	req.GitHubToken = config.GitHubToken
 	req.RemoteSession = config.RemoteSession
 	req.Canvases = config.Canvases

go/client_test.go

@@ -605,6 +605,70 @@ func TestSessionRequests_PluginDirectoriesAndLargeOutput(t *testing.T) {
 	})
 }
 
+func TestSessionRequests_Memory(t *testing.T) {
+	t.Run("create includes memory in JSON when enabled", func(t *testing.T) {
+		req := createSessionRequest{Memory: &MemoryConfiguration{Enabled: true}}
+		data, err := json.Marshal(req)
+		if err != nil {
+			t.Fatalf("Failed to marshal: %v", err)
+		}
+		var m map[string]any
+		if err := json.Unmarshal(data, &m); err != nil {
+			t.Fatalf("Failed to unmarshal: %v", err)
+		}
+		expected := map[string]any{"enabled": true}
+		if !reflect.DeepEqual(m["memory"], expected) {
+			t.Errorf("Expected memory %v, got %v", expected, m["memory"])
+		}
+	})
+
+	t.Run("resume includes memory in JSON when disabled", func(t *testing.T) {
+		req := resumeSessionRequest{SessionID: "s1", Memory: &MemoryConfiguration{Enabled: false}}
+		data, err := json.Marshal(req)
+		if err != nil {
+			t.Fatalf("Failed to marshal: %v", err)
+		}
+		var m map[string]any
+		if err := json.Unmarshal(data, &m); err != nil {
+			t.Fatalf("Failed to unmarshal: %v", err)
+		}
+		expected := map[string]any{"enabled": false}
+		if !reflect.DeepEqual(m["memory"], expected) {
+			t.Errorf("Expected memory %v, got %v", expected, m["memory"])
+		}
+	})
+
+	t.Run("create omits memory when nil", func(t *testing.T) {
+		req := createSessionRequest{}
+		data, err := json.Marshal(req)
+		if err != nil {
+			t.Fatalf("Failed to marshal: %v", err)
+		}
+		var m map[string]any
+		if err := json.Unmarshal(data, &m); err != nil {
+			t.Fatalf("Failed to unmarshal: %v", err)
+		}
+		if _, ok := m["memory"]; ok {
+			t.Errorf("Expected memory to be omitted")
+		}
+	})
+
+	t.Run("resume omits memory when nil", func(t *testing.T) {
+		req := resumeSessionRequest{SessionID: "s1"}
+		data, err := json.Marshal(req)
+		if err != nil {
+			t.Fatalf("Failed to marshal: %v", err)
+		}
+		var m map[string]any
+		if err := json.Unmarshal(data, &m); err != nil {
+			t.Fatalf("Failed to unmarshal: %v", err)
+		}
+		if _, ok := m["memory"]; ok {
+			t.Errorf("Expected memory to be omitted")
+		}
+	})
+}
+
 func TestCreateSessionRequest_Agent(t *testing.T) {
 	t.Run("includes agent in JSON when set", func(t *testing.T) {
 		req := createSessionRequest{Agent: "test-agent"}

go/mode_empty.go

@@ -154,6 +154,9 @@ func (c *Client) applyConfigDefaultsForMode(config *SessionConfig) {
 		f := false
 		config.EnableSkills = &f
 	}
+	if config.Memory == nil {
+		config.Memory = &MemoryConfiguration{Enabled: false}
+	}
 	if config.MCPOAuthTokenStorage == "" {
 		config.MCPOAuthTokenStorage = "in-memory"
 	}
@@ -195,6 +198,9 @@ func (c *Client) applyResumeDefaultsForMode(config *ResumeSessionConfig) {
 		f := false
 		config.EnableSkills = &f
 	}
+	if config.Memory == nil {
+		config.Memory = &MemoryConfiguration{Enabled: false}
+	}
 	if config.MCPOAuthTokenStorage == "" {
 		config.MCPOAuthTokenStorage = "in-memory"
 	}

go/toolset_test.go

@@ -273,6 +273,9 @@ func TestApplyConfigDefaultsForMode_emptyDefaultsGranularFlags(t *testing.T) {
 	if cfg.EnableSkills == nil || *cfg.EnableSkills != false {
 		t.Errorf("expected EnableSkills=false in empty mode, got %v", cfg.EnableSkills)
 	}
+	if cfg.Memory == nil || cfg.Memory.Enabled != false {
+		t.Errorf("expected Memory.Enabled=false in empty mode, got %v", cfg.Memory)
+	}
 }
 
 func TestApplyConfigDefaultsForMode_emptyHonorsCallerGranularFlags(t *testing.T) {
@@ -287,6 +290,7 @@ func TestApplyConfigDefaultsForMode_emptyHonorsCallerGranularFlags(t *testing.T)
 		EnableHostGitOperations:            &trueVal,
 		EnableSessionStore:                 &trueVal,
 		EnableSkills:                       &trueVal,
+		Memory:                             &MemoryConfiguration{Enabled: true},
 	}
 	c.applyConfigDefaultsForMode(cfg)
 	if *cfg.SkipEmbeddingRetrieval != false {
@@ -310,6 +314,9 @@ func TestApplyConfigDefaultsForMode_emptyHonorsCallerGranularFlags(t *testing.T)
 	if *cfg.EnableSkills != true {
 		t.Errorf("caller-supplied EnableSkills must win")
 	}
+	if cfg.Memory == nil || cfg.Memory.Enabled != true {
+		t.Errorf("caller-supplied Memory must win")
+	}
 }
 
 func TestApplyConfigDefaultsForMode_copilotCliLeavesGranularFlagsNil(t *testing.T) {
@@ -334,6 +341,9 @@ func TestApplyConfigDefaultsForMode_copilotCliLeavesGranularFlagsNil(t *testing.
 	if cfg.EnableSkills != nil {
 		t.Errorf("non-empty mode must not default EnableSkills")
 	}
+	if cfg.Memory != nil {
+		t.Errorf("non-empty mode must not default Memory")
+	}
 }
 
 func TestApplyConfigDefaultsForMode_emptyDefaultsMCPOAuthTokenStorage(t *testing.T) {