feat(csharp): add default-timeout-in-seconds generator config (#15801)

Adds a new `default-timeout-in-seconds` option to the C# SDK generator
custom config. When set, the generated `ClientOptions.Timeout` defaults
to the configured value (or `Timeout.InfiniteTimeSpan` when set to
"infinity") instead of the previously hardcoded 30 seconds. SDK users
can still override the timeout per-request via `RequestOptions.Timeout`.

This mirrors the existing config option in the Java/TypeScript/Python
generators.

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-authored-by: will.kendall@buildwithfern.com <wpk235@gmail.com>

Author: 3 people

generators/csharp/codegen/src/context/generation-info.ts

@@ -247,6 +247,8 @@ export class Generation {
         maxRetries: () => this.customConfig.maxRetries,
         /** Controls which HTTP status codes trigger automatic retries. Default: "legacy". */
         retryStatusCodes: () => this.customConfig.retryStatusCodes ?? "legacy",
+        /** Override the default request timeout (in seconds) for the generated SDK client. `"infinity"` disables the default timeout. Default: 30. */
+        defaultTimeoutInSeconds: () => this.customConfig["default-timeout-in-seconds"],
         /**
          * Output path configuration for generated files.
          * Returns normalized paths for library, test, solution, and other files.

generators/csharp/codegen/src/custom-config/CsharpConfigSchema.ts

@@ -117,7 +117,13 @@ export const CsharpConfigSchema = z.object({
     // "slnx" (default) generates only the modern .slnx format.
     "sln-format": z.enum(["sln", "slnx"]).optional(),
     maxRetries: z.number().int().min(0).optional(),
-    retryStatusCodes: z.optional(z.enum(["legacy", "recommended"]))
+    retryStatusCodes: z.optional(z.enum(["legacy", "recommended"])),
+    "default-timeout-in-seconds": z
+        .union([z.number().positive(), z.literal("infinity")])
+        .optional()
+        .describe(
+            "The default timeout for network requests, in seconds. Set to `infinity` to disable the default timeout. SDK users can still override this per-request via request options."
+        )
 });
 
 export type CsharpConfigSchema = z.infer<typeof CsharpConfigSchema>;

generators/csharp/codegen/src/custom-config/__test__/defaultTimeoutInSeconds.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { CsharpConfigSchema } from "../CsharpConfigSchema.js";
+
+describe("C# default-timeout-in-seconds config", () => {
+    it("should accept a positive number", () => {
+        const result = CsharpConfigSchema.safeParse({ "default-timeout-in-seconds": 60 });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data["default-timeout-in-seconds"]).toBe(60);
+        }
+    });
+
+    it("should accept fractional seconds", () => {
+        const result = CsharpConfigSchema.safeParse({ "default-timeout-in-seconds": 1.5 });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data["default-timeout-in-seconds"]).toBe(1.5);
+        }
+    });
+
+    it("should accept the literal 'infinity'", () => {
+        const result = CsharpConfigSchema.safeParse({ "default-timeout-in-seconds": "infinity" });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data["default-timeout-in-seconds"]).toBe("infinity");
+        }
+    });
+
+    it("should accept config without the option (optional)", () => {
+        const result = CsharpConfigSchema.safeParse({});
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data["default-timeout-in-seconds"]).toBeUndefined();
+        }
+    });
+
+    it("should reject zero", () => {
+        const result = CsharpConfigSchema.safeParse({ "default-timeout-in-seconds": 0 });
+        expect(result.success).toBe(false);
+    });
+
+    it("should reject negative numbers", () => {
+        const result = CsharpConfigSchema.safeParse({ "default-timeout-in-seconds": -1 });
+        expect(result.success).toBe(false);
+    });
+
+    it("should reject other strings", () => {
+        const result = CsharpConfigSchema.safeParse({ "default-timeout-in-seconds": "60" });
+        expect(result.success).toBe(false);
+    });
+});

generators/csharp/sdk/changes/unreleased/feat-default-timeout-in-seconds.yml

@@ -0,0 +1,9 @@
+# yaml-language-server: $schema=../../../../../fern-changes-yml.schema.json
+
+- summary: |
+    Add a `default-timeout-in-seconds` config option to the C# SDK generator.
+    When set, the generated `ClientOptions.Timeout` defaults to the configured
+    value (or `Timeout.InfiniteTimeSpan` when set to `"infinity"`) instead of
+    the previously hardcoded 30 seconds. SDK users can still override the
+    timeout per-request via `RequestOptions.Timeout`.
+  type: feat

generators/csharp/sdk/src/options/BaseOptionsGenerator.ts

@@ -94,13 +94,18 @@ export class BaseOptionsGenerator extends WithGeneration {
 
     public getTimeoutField(classOrInterface: ast.Interface | ast.Class, { optional, includeInitializer }: OptionArgs) {
         const type = this.System.TimeSpan;
+        const configured = this.settings.defaultTimeoutInSeconds;
+        const initializer =
+            configured === "infinity"
+                ? this.csharp.codeblock("System.Threading.Timeout.InfiniteTimeSpan")
+                : this.csharp.codeblock(`TimeSpan.FromSeconds(${configured ?? 30})`);
         classOrInterface.addField({
             origin: classOrInterface.explicit("Timeout"),
             access: ast.Access.Public,
             get: true,
             init: true,
             type: optional ? type.asOptional() : type,
-            initializer: includeInitializer ? this.csharp.codeblock("TimeSpan.FromSeconds(30)") : undefined,
+            initializer: includeInitializer ? initializer : undefined,
             summary: "The timeout for the request."
         });
     }