Fix CI failures for @github/copilot 1.0.32-1 update

- Add shared nullable-required schema normalization in codegen utils
  (converts required \ properties with null descriptions to anyOf pattern)
- Add Python forward-reference topological sort in codegen
- Update Go type alias for renamed PurpleModelCapabilitiesOverrideLimitsVision
- Add Go type conversion helper for duplicate quicktype-generated types
- Add Node.js model capabilities normalization (backfill supports/limits)
- Regenerate all language bindings with fixes applied

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

Author: stephentoub

dotnet/src/Generated/Rpc.cs

@@ -1213,7 +1213,7 @@ func (s *Session) SetModel(ctx context.Context, model string, opts *SetModelOpti
 	params := &rpc.ModelSwitchToRequest{ModelID: model}
 	if opts != nil {
 		params.ReasoningEffort = opts.ReasoningEffort
-		params.ModelCapabilities = opts.ModelCapabilities
+		params.ModelCapabilities = convertModelCapabilitiesToClass(opts.ModelCapabilities)
 	}
 	_, err := s.RPC.Model.SwitchTo(ctx, params)
 	if err != nil {
@@ -1223,7 +1223,33 @@ func (s *Session) SetModel(ctx context.Context, model string, opts *SetModelOpti
 	return nil
 }
 
-// LogOptions configures optional parameters for [Session.Log].
+// convertModelCapabilitiesToClass converts from ModelCapabilitiesOverride
+// (used in the public API) to ModelCapabilitiesClass (used internally by
+// the ModelSwitchToRequest RPC). The two types are structurally identical
+// but have different Go types due to code generation.
+func convertModelCapabilitiesToClass(src *rpc.ModelCapabilitiesOverride) *rpc.ModelCapabilitiesClass {
+	if src == nil {
+		return nil
+	}
+	dst := &rpc.ModelCapabilitiesClass{
+		Supports: src.Supports,
+	}
+	if src.Limits != nil {
+		dst.Limits = &rpc.ModelCapabilitiesLimitsClass{
+			MaxContextWindowTokens: src.Limits.MaxContextWindowTokens,
+			MaxOutputTokens:        src.Limits.MaxOutputTokens,
+			MaxPromptTokens:        src.Limits.MaxPromptTokens,
+		}
+		if src.Limits.Vision != nil {
+			dst.Limits.Vision = &rpc.FluffyModelCapabilitiesOverrideLimitsVision{
+				MaxPromptImageSize:  src.Limits.Vision.MaxPromptImageSize,
+				MaxPromptImages:     src.Limits.Vision.MaxPromptImages,
+				SupportedMediaTypes: src.Limits.Vision.SupportedMediaTypes,
+			}
+		}
+	}
+	return dst
+}
 type LogOptions struct {
 	// Level sets the log severity. Valid values are [rpc.SessionLogLevelInfo] (default),
 	// [rpc.SessionLogLevelWarning], and [rpc.SessionLogLevelError].

go/rpc/generated_rpc.go

@@ -848,7 +848,7 @@ type (
 	ModelCapabilitiesOverride             = rpc.ModelCapabilitiesOverride
 	ModelCapabilitiesOverrideSupports     = rpc.ModelCapabilitiesOverrideSupports
 	ModelCapabilitiesOverrideLimits       = rpc.ModelCapabilitiesOverrideLimits
-	ModelCapabilitiesOverrideLimitsVision = rpc.ModelCapabilitiesOverrideLimitsVision
+	ModelCapabilitiesOverrideLimitsVision = rpc.PurpleModelCapabilitiesOverrideLimitsVision
 )
 
 // ModelPolicy contains model policy state

go/session.go

@@ -1019,6 +1019,28 @@ export class CopilotClient {
                 const result = await this.connection.sendRequest("models.list", {});
                 const response = result as { models: ModelInfo[] };
                 models = response.models;
+
+                // Normalize model capabilities — some models (e.g. embedding models)
+                // may omit 'supports' or 'limits' in their capabilities.
+                for (const model of models) {
+                    const caps = model.capabilities as Record<string, unknown> | undefined;
+                    if (!caps) {
+                        (model as Record<string, unknown>).capabilities = {
+                            supports: {},
+                            limits: { max_context_window_tokens: 0 },
+                        };
+                    } else {
+                        if (!caps.supports) caps.supports = {};
+                        if (!caps.limits) {
+                            caps.limits = { max_context_window_tokens: 0 };
+                        } else if (
+                            (caps.limits as Record<string, unknown>).max_context_window_tokens ===
+                            undefined
+                        ) {
+                            (caps.limits as Record<string, unknown>).max_context_window_tokens = 0;
+                        }
+                    }
+                }
             }
 
             // Update cache before releasing lock (copy to prevent external mutation)