Fix optional RPC request codegen

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

Author: Copilot

dotnet/src/Generated/Rpc.cs

@@ -105,6 +105,19 @@ impl<'a> ClientRpcAccount<'a> {
             .await?;
         Ok(serde_json::from_value(_value)?)
     }
+
+    /// Wire method: `account.getQuota`.
+    pub async fn get_quota_with_params(
+        &self,
+        params: AccountGetQuotaRequest,
+    ) -> Result<AccountGetQuotaResult, Error> {
+        let wire_params = serde_json::to_value(params)?;
+        let _value = self
+            .client
+            .call(rpc_methods::ACCOUNT_GETQUOTA, Some(wire_params))
+            .await?;
+        Ok(serde_json::from_value(_value)?)
+    }
 }
 
 /// `mcp.*` RPCs.
@@ -216,6 +229,16 @@ impl<'a> ClientRpcModels<'a> {
             .await?;
         Ok(serde_json::from_value(_value)?)
     }
+
+    /// Wire method: `models.list`.
+    pub async fn list_with_params(&self, params: ModelsListRequest) -> Result<ModelList, Error> {
+        let wire_params = serde_json::to_value(params)?;
+        let _value = self
+            .client
+            .call(rpc_methods::MODELS_LIST, Some(wire_params))
+            .await?;
+        Ok(serde_json::from_value(_value)?)
+    }
 }
 
 /// `sessionFs.*` RPCs.
@@ -658,6 +681,21 @@ impl<'a> SessionRpcCommands<'a> {
         Ok(serde_json::from_value(_value)?)
     }
 
+    /// Wire method: `session.commands.list`.
+    pub async fn list_with_params(
+        &self,
+        params: CommandsListRequest,
+    ) -> Result<CommandList, Error> {
+        let mut wire_params = serde_json::to_value(params)?;
+        wire_params["sessionId"] = serde_json::Value::String(self.session.id().to_string());
+        let _value = self
+            .session
+            .client()
+            .call(rpc_methods::SESSION_COMMANDS_LIST, Some(wire_params))
+            .await?;
+        Ok(serde_json::from_value(_value)?)
+    }
+
     /// Wire method: `session.commands.invoke`.
     pub async fn invoke(
         &self,

go/rpc/zrpc.go

@@ -1506,6 +1506,10 @@ function emitSessionMethod(key: string, method: RpcMethod, lines: string[], clas
     const effectiveParams = resolveMethodParamsSchema(method);
     const paramEntries = (effectiveParams?.properties ? Object.entries(effectiveParams.properties) : []).filter(([k]) => k !== "sessionId");
     const requiredSet = new Set(effectiveParams?.required || []);
+    const useRequestParameter =
+        paramEntries.length > 0 &&
+        !!getNullableInner(method.params) &&
+        paramEntries.every(([name]) => !requiredSet.has(name));
 
     // Sort so required params come before optional (C# requires defaults at end)
     paramEntries.sort((a, b) => {
@@ -1515,12 +1519,28 @@ function emitSessionMethod(key: string, method: RpcMethod, lines: string[], clas
     });
 
     const requestClassName = paramsTypeName(method);
+    const wireRequestClassName = useRequestParameter ? `${requestClassName}WithSession` : requestClassName;
     if (method.stability === "experimental") {
         experimentalRpcTypes.add(requestClassName);
+        if (useRequestParameter) {
+            experimentalRpcTypes.add(wireRequestClassName);
+        }
     }
     if (effectiveParams?.properties && Object.keys(effectiveParams.properties).length > 0) {
-        const reqClass = emitRpcClass(requestClassName, effectiveParams, "internal", classes);
-        if (reqClass) classes.push(reqClass);
+        if (useRequestParameter) {
+            const publicParams: JSONSchema7 = {
+                ...effectiveParams,
+                properties: Object.fromEntries(paramEntries),
+                required: effectiveParams.required?.filter((name) => name !== "sessionId"),
+            };
+            const publicReqClass = emitRpcClass(requestClassName, publicParams, methodVisibility, classes);
+            if (publicReqClass) classes.push(publicReqClass);
+            const wireReqClass = emitRpcClass(wireRequestClassName, effectiveParams, "internal", classes);
+            if (wireReqClass) classes.push(wireReqClass);
+        } else {
+            const reqClass = emitRpcClass(requestClassName, effectiveParams, "internal", classes);
+            if (reqClass) classes.push(reqClass);
+        }
     }
 
     lines.push("", `${indent}/// <summary>Calls "${method.rpcMethod}".</summary>`);
@@ -1533,22 +1553,30 @@ function emitSessionMethod(key: string, method: RpcMethod, lines: string[], clas
     const sigParams: string[] = [];
     const bodyAssignments = [`SessionId = _sessionId`];
 
-    for (const [pName, pSchema] of paramEntries) {
-        if (typeof pSchema !== "object") continue;
-        const isReq = requiredSet.has(pName);
-        const csType = resolveRpcType(pSchema as JSONSchema7, isReq, requestClassName, toPascalCase(pName), classes);
-        sigParams.push(`${csType} ${pName}${isReq ? "" : " = null"}`);
-        bodyAssignments.push(`${toPascalCase(pName)} = ${pName}`);
+    if (useRequestParameter) {
+        sigParams.push(`${requestClassName}? request = null`);
+        for (const [pName] of paramEntries) {
+            bodyAssignments.push(`${toPascalCase(pName)} = request?.${toPascalCase(pName)}`);
+        }
+    } else {
+        for (const [pName, pSchema] of paramEntries) {
+            if (typeof pSchema !== "object") continue;
+            const isReq = requiredSet.has(pName);
+            const csType = resolveRpcType(pSchema as JSONSchema7, isReq, requestClassName, toPascalCase(pName), classes);
+            sigParams.push(`${csType} ${pName}${isReq ? "" : " = null"}`);
+            bodyAssignments.push(`${toPascalCase(pName)} = ${pName}`);
+        }
     }
     sigParams.push("CancellationToken cancellationToken = default");
 
     const taskType = !isVoidSchema(resultSchema) ? `Task<${resultClassName}>` : "Task";
+    const localRequestName = useRequestParameter ? "rpcRequest" : "request";
     lines.push(`${indent}${methodVisibility} async ${taskType} ${methodName}Async(${sigParams.join(", ")})`);
-    lines.push(`${indent}{`, `${indent}    var request = new ${requestClassName} { ${bodyAssignments.join(", ")} };`);
+    lines.push(`${indent}{`, `${indent}    var ${localRequestName} = new ${wireRequestClassName} { ${bodyAssignments.join(", ")} };`);
     if (!isVoidSchema(resultSchema)) {
-        lines.push(`${indent}    return await CopilotClient.InvokeRpcAsync<${resultClassName}>(_rpc, "${method.rpcMethod}", [request], cancellationToken);`, `${indent}}`);
+        lines.push(`${indent}    return await CopilotClient.InvokeRpcAsync<${resultClassName}>(_rpc, "${method.rpcMethod}", [${localRequestName}], cancellationToken);`, `${indent}}`);
     } else {
-        lines.push(`${indent}    await CopilotClient.InvokeRpcAsync(_rpc, "${method.rpcMethod}", [request], cancellationToken);`, `${indent}}`);
+        lines.push(`${indent}    await CopilotClient.InvokeRpcAsync(_rpc, "${method.rpcMethod}", [${localRequestName}], cancellationToken);`, `${indent}}`);
     }
 }
 

nodejs/src/generated/rpc.ts

@@ -3338,6 +3338,8 @@ function emitMethod(lines: string[], receiver: string, name: string, method: Rpc
         .sort((left, right) => compareGoFieldNames(toGoFieldName(left), toGoFieldName(right)));
     const hasParams = isSession ? nonSessionParams.length > 0 : hasSchemaPayload(effectiveParams);
     const paramsType = hasParams ? resolveType(goParamsTypeName(method)) : "";
+    const hasRequiredNonSessionParams = nonSessionParams.some((name) => requiredParams.has(name));
+    const paramsAreOptional = hasParams && !!method.params && !!getNullableInner(method.params) && !hasRequiredNonSessionParams;
 
     // For wrapper-level methods, access fields through a.common; for service type aliases, use a directly
     const clientRef = isWrapper ? "a.common.client" : "a.client";
@@ -3353,15 +3355,22 @@ function emitMethod(lines: string[], receiver: string, name: string, method: Rpc
         pushGoComment(lines, `Internal: ${methodName} is part of the SDK's internal handshake/plumbing; external callers should not use it.`);
     }
     const sig = hasParams
-        ? `func (a *${receiver}) ${methodName}(ctx context.Context, params *${paramsType}) (${returnType}, error)`
+        ? `func (a *${receiver}) ${methodName}(ctx context.Context, params ${paramsAreOptional ? "..." : ""}*${paramsType}) (${returnType}, error)`
         : `func (a *${receiver}) ${methodName}(ctx context.Context) (${returnType}, error)`;
 
     lines.push(sig + ` {`);
+    const paramsRef = paramsAreOptional ? "requestParams" : "params";
+    if (paramsAreOptional) {
+        lines.push(`\tvar requestParams *${paramsType}`);
+        lines.push(`\tif len(params) > 0 {`);
+        lines.push(`\t\trequestParams = params[0]`);
+        lines.push(`\t}`);
+    }
 
     if (isSession) {
         lines.push(`\treq := map[string]any{"sessionId": ${sessionIDRef}}`);
         if (hasParams) {
-            lines.push(`\tif params != nil {`);
+            lines.push(`\tif ${paramsRef} != nil {`);
             for (const pName of nonSessionParams) {
                 const field = fields.get(paramsType)?.get(pName);
                 const goField = field?.name ?? toGoFieldName(pName);
@@ -3370,19 +3379,19 @@ function emitMethod(lines: string[], receiver: string, name: string, method: Rpc
                 if (isOptional) {
                     // Optional fields are usually pointers; generated union interfaces, slices,
                     // and maps are nilable values and should be passed through directly.
-                    lines.push(`\t\tif params.${goField} != nil {`);
-                    const valueExpr = goOptionalFieldNeedsDereference(goType) ? `*params.${goField}` : `params.${goField}`;
+                    lines.push(`\t\tif ${paramsRef}.${goField} != nil {`);
+                    const valueExpr = goOptionalFieldNeedsDereference(goType) ? `*${paramsRef}.${goField}` : `${paramsRef}.${goField}`;
                     lines.push(`\t\t\treq["${pName}"] = ${valueExpr}`);
                     lines.push(`\t\t}`);
                 } else {
-                    lines.push(`\t\treq["${pName}"] = params.${goField}`);
+                    lines.push(`\t\treq["${pName}"] = ${paramsRef}.${goField}`);
                 }
             }
             lines.push(`\t}`);
         }
         lines.push(`\traw, err := ${clientRef}.Request("${method.rpcMethod}", req)`);
     } else {
-        const arg = hasParams ? "params" : "nil";
+        const arg = hasParams ? paramsRef : "nil";
         lines.push(`\traw, err := ${clientRef}.Request("${method.rpcMethod}", ${arg})`);
     }
 

python/copilot/generated/rpc.py

@@ -2084,7 +2084,7 @@ function emitRpcWrapper(lines: string[], node: Record<string, unknown>, isSessio
     } else {
         lines.push(`class ${wrapperName}:`);
         lines.push(classPrefix === "_Internal"
-            ? `    """Internal SDK server-scoped RPC methods (handshake helpers etc.). Not part of the public API."""`
+            ? `    """Internal SDK server-scoped RPC methods. Not part of the public API."""`
             : `    """Typed server-scoped RPC methods."""`);
         lines.push(`    def __init__(self, client: "JsonRpcClient"):`);
         lines.push(`        self._client = client`);