Expose large output config on custom agents

Author: xianjianlf2

dotnet/src/Types.cs

@@ -2796,6 +2796,13 @@ public sealed class CustomAgentConfig
     /// </summary>
     [JsonPropertyName("reasoningEffort")]
     public string? ReasoningEffort { get; set; }
+
+    /// <summary>
+    /// Large tool output handling for this agent.
+    /// </summary>
+    /// <remarks>When omitted, no agent-specific large output override is sent.</remarks>
+    [JsonPropertyName("largeOutput")]
+    public LargeToolOutputConfig? LargeOutput { get; set; }
 }
 
 /// <summary>

dotnet/test/Unit/SerializationTests.cs

@@ -444,6 +444,31 @@ public void SessionRequests_CanSerializePluginDirectoriesAndLargeOutput_WithSdkO
         Assert.Equal("/tmp/large-output", resumeLargeOutput.GetProperty("outputDir").GetString());
     }
 
+    [Fact]
+    public void CustomAgentConfig_CanSerializeLargeOutput_WithSdkOptions()
+    {
+        var options = GetSerializerOptions();
+        var agent = new CustomAgentConfig
+        {
+            Name = "large-output-agent",
+            Prompt = "Handle large outputs.",
+            LargeOutput = new LargeToolOutputConfig
+            {
+                Enabled = false,
+                MaxSizeBytes = 2048,
+                OutputDirectory = "/tmp/agent-large-output",
+            },
+        };
+
+        var json = JsonSerializer.Serialize(agent, options);
+        using var document = JsonDocument.Parse(json);
+        var largeOutput = document.RootElement.GetProperty("largeOutput");
+
+        Assert.False(largeOutput.GetProperty("enabled").GetBoolean());
+        Assert.Equal(2048, largeOutput.GetProperty("maxSizeBytes").GetInt64());
+        Assert.Equal("/tmp/agent-large-output", largeOutput.GetProperty("outputDir").GetString());
+    }
+
     [Fact]
     public void SessionRequests_CanSerializeMemory_WithSdkOptions()
     {

go/types.go

@@ -1043,6 +1043,9 @@ type CustomAgentConfig struct {
 	// When empty, the runtime resolves model configuration, then inherits the
 	// parent effort only for the same model.
 	ReasoningEffort string `json:"reasoningEffort,omitempty"`
+	// LargeOutput configures large tool output handling for this agent. When
+	// nil, no agent-specific large output override is sent.
+	LargeOutput *LargeToolOutputConfig `json:"largeOutput,omitempty"`
 }
 
 // DefaultAgentConfig configures the default agent (the built-in agent that handles turns when no custom agent is selected).

go/types_test.go

@@ -186,6 +186,44 @@ func TestCustomAgentConfig_JSONIncludesReasoningEffort(t *testing.T) {
 	}
 }
 
+func TestCustomAgentConfig_JSONIncludesLargeOutput(t *testing.T) {
+	enabled := false
+	maxSizeBytes := int64(2048)
+	cfg := CustomAgentConfig{
+		Name:   "large-output-agent",
+		Prompt: "Handle large outputs.",
+		LargeOutput: &LargeToolOutputConfig{
+			Enabled:         &enabled,
+			MaxSizeBytes:    &maxSizeBytes,
+			OutputDirectory: "/tmp/agent-large-output",
+		},
+	}
+
+	data, err := json.Marshal(cfg)
+	if err != nil {
+		t.Fatalf("failed to marshal CustomAgentConfig: %v", err)
+	}
+
+	var decoded map[string]any
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		t.Fatalf("failed to unmarshal CustomAgentConfig: %v", err)
+	}
+
+	largeOutput, ok := decoded["largeOutput"].(map[string]any)
+	if !ok {
+		t.Fatalf("expected largeOutput object, got %v", decoded["largeOutput"])
+	}
+	if largeOutput["enabled"] != false {
+		t.Errorf("expected enabled false, got %v", largeOutput["enabled"])
+	}
+	if largeOutput["maxSizeBytes"] != float64(2048) {
+		t.Errorf("expected maxSizeBytes 2048, got %v", largeOutput["maxSizeBytes"])
+	}
+	if largeOutput["outputDir"] != "/tmp/agent-large-output" {
+		t.Errorf("expected outputDir '/tmp/agent-large-output', got %v", largeOutput["outputDir"])
+	}
+}
+
 func TestCustomAgentConfig_JSONIncludesEmptyTools(t *testing.T) {
 	cfg := CustomAgentConfig{
 		Name:   "no-tools-agent",

java/sdk/src/main/java/com/github/copilot/rpc/CustomAgentConfig.java

@@ -66,6 +66,9 @@ public class CustomAgentConfig {
     @JsonProperty("reasoningEffort")
     private String reasoningEffort;
 
+    @JsonProperty("largeOutput")
+    private LargeToolOutputConfig largeOutput;
+
     /**
      * Gets the unique identifier name for this agent.
      *
@@ -309,4 +312,27 @@ public CustomAgentConfig setReasoningEffort(String reasoningEffort) {
         this.reasoningEffort = reasoningEffort;
         return this;
     }
+
+    /**
+     * Gets the large tool output handling configuration for this agent.
+     *
+     * @return the large output configuration, or {@code null} if not set
+     */
+    public LargeToolOutputConfig getLargeOutput() {
+        return largeOutput;
+    }
+
+    /**
+     * Sets the large tool output handling configuration for this agent.
+     * <p>
+     * When omitted, no agent-specific large output override is sent.
+     *
+     * @param largeOutput
+     *            the large output configuration
+     * @return this config for method chaining
+     */
+    public CustomAgentConfig setLargeOutput(LargeToolOutputConfig largeOutput) {
+        this.largeOutput = largeOutput;
+        return this;
+    }
 }

java/sdk/src/test/java/com/github/copilot/DataObjectCoverageTest.java

@@ -278,6 +278,24 @@ void customAgentConfigReasoningEffortOmittedWhenNull() throws Exception {
         assertFalse(json.contains("\"reasoningEffort\""));
     }
 
+    @Test
+    void customAgentConfigLargeOutputSerializationRoundTrip() throws Exception {
+        var mapper = JsonRpcClient.getObjectMapper();
+        var cfg = new CustomAgentConfig().setName("large-output-agent")
+                .setLargeOutput(new LargeToolOutputConfig().setEnabled(false).setMaxSizeBytes(2048L)
+                        .setOutputDirectory("/tmp/agent-large-output"));
+
+        var json = mapper.writeValueAsString(cfg);
+        assertTrue(json.contains("\"largeOutput\""));
+        assertTrue(json.contains("\"outputDir\":\"/tmp/agent-large-output\""));
+
+        var deserialized = mapper.readValue(json, CustomAgentConfig.class);
+        assertNotNull(deserialized.getLargeOutput());
+        assertEquals(false, deserialized.getLargeOutput().getEnabled());
+        assertEquals(2048L, deserialized.getLargeOutput().getMaxSizeBytes());
+        assertEquals("/tmp/agent-large-output", deserialized.getLargeOutput().getOutputDirectory());
+    }
+
     // ===== PermissionRequestResult setRules =====
 
     @Test

nodejs/src/client.ts

@@ -248,9 +248,12 @@ function toWireMcpServers(
 function toWireCustomAgents(agents: CustomAgentConfig[] | undefined): unknown[] | undefined {
     if (!agents) return undefined;
     return agents.map((agent) => {
-        if (!agent.mcpServers) return agent;
-        const { mcpServers, ...rest } = agent;
-        return { ...rest, mcpServers: toWireMcpServers(mcpServers) };
+        const { mcpServers, largeOutput, ...rest } = agent;
+        return {
+            ...rest,
+            ...(mcpServers ? { mcpServers: toWireMcpServers(mcpServers) } : {}),
+            ...(largeOutput ? { largeOutput: toWireLargeOutput(largeOutput) } : {}),
+        };
     });
 }
 

nodejs/src/types.ts

@@ -1791,6 +1791,11 @@ export interface CustomAgentConfig {
      * then inherits the parent effort only if this agent uses the same model.
      */
     reasoningEffort?: ReasoningEffort;
+    /**
+     * Large tool output handling for this agent.
+     * When unset, no agent-specific large output override is sent.
+     */
+    largeOutput?: LargeToolOutputConfig;
 }
 
 /**

nodejs/test/client.test.ts

@@ -2646,6 +2646,40 @@ describe("CopilotClient", () => {
             ]);
         });
 
+        it("forwards custom agent large output in session.create request", async () => {
+            const client = new CopilotClient();
+            await client.start();
+            onTestFinished(() => stopClient(client));
+
+            const spy = vi.spyOn((client as any).connection!, "sendRequest");
+            await client.createSession({
+                onPermissionRequest: approveAll,
+                customAgents: [
+                    {
+                        name: "large-output-agent",
+                        prompt: "You are a large output agent.",
+                        largeOutput: {
+                            enabled: false,
+                            maxSizeBytes: 2048,
+                            outputDirectory: "/tmp/agent-large-output",
+                        },
+                    },
+                ],
+            });
+
+            const payload = spy.mock.calls.find((c) => c[0] === "session.create")![1] as any;
+            expect(payload.customAgents).toEqual([
+                expect.objectContaining({
+                    name: "large-output-agent",
+                    largeOutput: {
+                        enabled: false,
+                        maxSizeBytes: 2048,
+                        outputDir: "/tmp/agent-large-output",
+                    },
+                }),
+            ]);
+        });
+
         it("forwards agent in session.resume request", async () => {
             const client = new CopilotClient();
             await client.start();

python/copilot/client.py

@@ -4035,6 +4035,8 @@ def _convert_custom_agent_to_wire_format(
             wire_agent["model"] = agent["model"]
         if "reasoning_effort" in agent:
             wire_agent["reasoningEffort"] = agent["reasoning_effort"]
+        if "large_output" in agent:
+            wire_agent["largeOutput"] = _large_output_to_wire(agent["large_output"])
         return wire_agent
 
     def _convert_default_agent_to_wire_format(