Why reflect.ValueOf() gives different output in called function and calling function in golang?

Why the outputs of s and s1 differs although the starting value is same ? Help me understand

package main

import (
	"fmt"
	"reflect"
)

type Auth struct {
	a, b interface{}
}

func main() {
	fmt.Println("--------p1,s1--------")
	p1 := Auth{}
	fmt.Println(p1)
	s1 := reflect.ValueOf(p1)
	fmt.Println(s1)

	fmt.Println("-------s---------")
	callFunc(p1)

}

func callFunc(a ...interface{}) {
	s := reflect.ValueOf(a)
	fmt.Println(s)

}

Ps. Filename is nil.go
On running the code using :go run nil.go
The output is :

The fmt package documents that when printing reflect.Value values, it prints the value wrapped inside them:

> Except when printed using the verbs %T and %p, special formatting considerations apply for operands that implement certain interfaces. In order of application:
> 1. If the operand is a reflect.Value, the operand is replaced by the concrete value that it holds, and printing continues with the next rule.
>
> [...]

callFunc() has a variadic parameter:

func callFunc(a ...interface{}) 

This means a is a slice. So when printing reflect.ValueOf(a), you'll get the slice printed. And the fmt package also documents that:

> For compound objects, the elements are printed using these rules, recursively, laid out like this:
>
> struct: {field0 field1 ...}
> array, slice: [elem0 elem1 ...]
> maps: map[key1:value1 key2:value2 ...]
> pointer to above: &{}, &[], &map[]

Slices are printed enclosed in square brackets.

Note that if callFunc() would not be variadic:

func callFunc(a interface{}) {
	s := reflect.ValueOf(a)
	fmt.Println(s)
}

Then output would be the same (try it on the Go Playground):

--------p1,s1--------
{<nil> <nil>}
{<nil> <nil>}
-------s---------
{<nil> <nil>}