feat(go): add clientDefault support to Go SDK generator

generators/go-v2/sdk/src/authUtils.ts

@@ -78,6 +78,21 @@ export function getRequestPropertyValueType(requestProperty: FernIr.RequestPrope
     return undefined;
 }
 
+/**
+ * Returns true if the given type reference is a non-optional, non-nullable string primitive.
+ * Used to guard clientDefault generation, since the `== ""` zero-value check
+ * and string assignment only compile for Go `string` types (not `*string`).
+ */
+export function isPlainStringType(typeRef: FernIr.TypeReference): boolean {
+    if (typeRef.type === "container") {
+        return false;
+    }
+    if (typeRef.type === "primitive") {
+        return typeRef.primitive.v1 === FernIr.PrimitiveTypeV1.String;
+    }
+    return false;
+}
+
 /**
  * Checks if a type reference is optional.
  */

generators/go-v2/sdk/src/client/ClientGenerator.ts

@@ -9,6 +9,7 @@ import {
     getInferredAuthScheme,
     getOAuthClientCredentialsScheme,
     getRequestPropertyFieldName,
+    isPlainStringType,
     isRequestPropertyOptional,
     isTypeReferenceOptional,
     resolveTokenEndpointBodyProperties
@@ -231,14 +232,21 @@ export class ClientGenerator extends FileGenerator<GoFile, SdkCustomConfigSchema
 
     private writeHeaderEnvironmentVariables({ writer }: { writer: go.Writer }): void {
         for (const header of this.context.ir.headers) {
-            if (header.env == null) {
-                continue;
+            if (header.env != null) {
+                this.writeEnvConditional({
+                    writer,
+                    propertyReference: this.getOptionsPropertyReference(header.name),
+                    env: header.env
+                });
+            }
+            // After env fallback, apply clientDefault if present and type is plain string
+            if (header.clientDefault != null && isPlainStringType(header.valueType)) {
+                this.writeClientDefaultConditional({
+                    writer,
+                    propertyReference: this.getOptionsPropertyReference(header.name),
+                    clientDefault: header.clientDefault
+                });
             }
-            this.writeEnvConditional({
-                writer,
-                propertyReference: this.getOptionsPropertyReference(header.name),
-                env: header.env
-            });
         }
     }
 
@@ -893,6 +901,27 @@ export class ClientGenerator extends FileGenerator<GoFile, SdkCustomConfigSchema
         writer.writeLine("}");
     }
 
+    private writeClientDefaultConditional({
+        writer,
+        propertyReference,
+        clientDefault
+    }: {
+        writer: go.Writer;
+        propertyReference: go.Selector;
+        clientDefault: FernIr.Literal;
+    }): void {
+        writer.write("if ");
+        writer.writeNode(propertyReference);
+        writer.writeLine(' == "" {');
+        writer.indent();
+        writer.writeNode(propertyReference);
+        writer.write(" = ");
+        writer.writeNode(this.context.getLiteralValue(clientDefault));
+        writer.newLine();
+        writer.dedent();
+        writer.writeLine("}");
+    }
+
     private getOptionsPropertyReference(name: NameInput): go.Selector {
         return go.selector({
             on: go.codeblock("options"),

generators/go-v2/sdk/src/endpoint/http/HttpEndpointGenerator.ts

@@ -3,6 +3,7 @@ import { assertNever } from "@fern-api/core-utils";
 import { go } from "@fern-api/go-ast";
 import { FernIr } from "@fern-fern/ir-sdk";
 
+import { isPlainStringType } from "../../authUtils.js";
 import { SdkGeneratorContext } from "../../SdkGeneratorContext.js";
 import { AbstractEndpointGenerator } from "../AbstractEndpointGenerator.js";
 import { EndpointSignatureInfo } from "../EndpointSignatureInfo.js";
@@ -620,19 +621,48 @@ export class HttpEndpointGenerator extends AbstractEndpointGenerator {
         const pathSuffix = this.getPathSuffix({ endpoint });
         const baseUrl = pathSuffix.length === 0 ? "baseURL" : `baseURL + "/${pathSuffix}"`;
         return go.codeblock((writer) => {
-            writer.write("endpointURL := ");
             if (endpoint.allPathParameters.length === 0) {
+                writer.write("endpointURL := ");
                 writer.write(baseUrl);
                 return;
             }
+            // Apply clientDefault fallback for path parameters before URL encoding.
+            // Use local variables to avoid mutating the caller's request struct when
+            // path params come from a wrapped request (e.g., request.Region).
+            const pathParamLocalVars: Record<string, string> = {};
+            for (const pathParameter of endpoint.allPathParameters) {
+                if (pathParameter.clientDefault != null && isPlainStringType(pathParameter.valueType)) {
+                    const ref = signature.pathParameterReferences[getOriginalName(pathParameter.name)];
+                    if (ref != null) {
+                        const localVar = `_${this.context.getFieldName(pathParameter.name)}`;
+                        writer.writeLine(`${localVar} := ${ref}`);
+                        writer.writeLine(`if ${localVar} == "" {`);
+                        writer.indent();
+                        writer.write(`${localVar} = `);
+                        writer.writeNode(this.context.getLiteralValue(pathParameter.clientDefault));
+                        writer.newLine();
+                        writer.dedent();
+                        writer.writeLine("}");
+                        pathParamLocalVars[getOriginalName(pathParameter.name)] = localVar;
+                    }
+                }
+            }
             const pathParameterReferences: go.AstNode[] = [];
             for (const pathParameter of endpoint.allPathParameters) {
-                const pathParameterReference = signature.pathParameterReferences[getOriginalName(pathParameter.name)];
+                const originalName = getOriginalName(pathParameter.name);
+                // Use the local variable if we created one for clientDefault
+                const localVar = pathParamLocalVars[originalName];
+                if (localVar != null) {
+                    pathParameterReferences.push(go.codeblock(localVar));
+                    continue;
+                }
+                const pathParameterReference = signature.pathParameterReferences[originalName];
                 if (pathParameterReference == null) {
                     continue;
                 }
                 pathParameterReferences.push(go.codeblock(pathParameterReference));
             }
+            writer.write("endpointURL := ");
             writer.writeNode(this.context.callEncodeUrl([go.codeblock(baseUrl), ...pathParameterReferences]));
         });
     }
@@ -725,7 +755,7 @@ export class HttpEndpointGenerator extends AbstractEndpointGenerator {
             return undefined;
         }
 
-        // extract and populate defaults
+        // extract and populate defaults (from type-level defaults and clientDefault)
         const defaults = [];
         if (this.context.customConfig.useDefaultRequestParameterValues) {
             for (const queryParameter of endpoint.queryParameters) {
@@ -739,6 +769,33 @@ export class HttpEndpointGenerator extends AbstractEndpointGenerator {
                 });
             }
         }
+        // Track wire values that already have type-level defaults
+        const defaultedWireValues = new Set<string>();
+        if (this.context.customConfig.useDefaultRequestParameterValues) {
+            for (const queryParameter of endpoint.queryParameters) {
+                if (this.extractDefaultValue(queryParameter.valueType) != null) {
+                    defaultedWireValues.add(getWireValue(queryParameter.name));
+                }
+            }
+        }
+        // Add clientDefault entries for query params that don't already have a type-level default.
+        // Unlike path params and headers (which use the == "" zero-value pattern and require
+        // string types), query params use a defaults map so any literal type works here.
+        for (const queryParameter of endpoint.queryParameters) {
+            if (queryParameter.clientDefault != null) {
+                const wireValue = getWireValue(queryParameter.name);
+                if (!defaultedWireValues.has(wireValue)) {
+                    const literalString =
+                        queryParameter.clientDefault.type === "string"
+                            ? queryParameter.clientDefault.string
+                            : String(queryParameter.clientDefault.boolean);
+                    defaults.push({
+                        key: go.TypeInstantiation.string(wireValue),
+                        value: go.TypeInstantiation.string(literalString)
+                    });
+                }
+            }
+        }
         const defaults_map = go.TypeInstantiation.map({
             keyType: go.Type.string(),
             valueType: go.Type.any(),
@@ -849,9 +906,27 @@ export class HttpEndpointGenerator extends AbstractEndpointGenerator {
                     writer.writeLine("}");
                     continue;
                 }
-                writer.writeNode(
-                    this.addHeaderValue({ wireValue: getWireValue(header.name), value: format.formatted })
-                );
+                // Apply clientDefault fallback for non-optional string headers.
+                // Use a local variable to avoid mutating the caller's request struct.
+                if (header.clientDefault != null && isPlainStringType(header.valueType)) {
+                    const localVar = `_${this.context.getFieldName(headerNameVal)}`;
+                    writer.writeNewLineIfLastLineNot();
+                    writer.writeLine(`${localVar} := ${headerField}`);
+                    writer.writeLine(`if ${localVar} == "" {`);
+                    writer.indent();
+                    writer.write(`${localVar} = `);
+                    writer.writeNode(this.context.getLiteralValue(header.clientDefault));
+                    writer.newLine();
+                    writer.dedent();
+                    writer.writeLine("}");
+                    writer.writeNode(
+                        this.addHeaderValue({ wireValue: getWireValue(header.name), value: go.codeblock(localVar) })
+                    );
+                } else {
+                    writer.writeNode(
+                        this.addHeaderValue({ wireValue: getWireValue(header.name), value: format.formatted })
+                    );
+                }
             }
             const acceptHeader = this.getAcceptHeaderValue({ endpoint });
             if (acceptHeader != null) {