Sampling Parameters

The pointer#

Temperature *float64
TopP        *float64

Temperature *float64
TopP        *float64

nil means "do not send this field at all" — the provider applies its own default. A non-nil pointer means "send exactly this".

With a plain float64, 0 would be indistinguishable from unset, and temperature zero is a value people genuinely want.

func f(v float64) *float64 { return &v }

req := &skyl.Request{
	Model:       "gpt-5.6",
	MaxTokens:   512,
	Temperature: f(0),   // explicitly deterministic — NOT "unset"
	Messages:    []skyl.Message{skyl.UserText("Extract the invoice number.")},
}

func f(v float64) *float64 { return &v }

req := &skyl.Request{
	Model:       "gpt-5.6",
	MaxTokens:   512,
	Temperature: f(0),   // explicitly deterministic — NOT "unset"
	Messages:    []skyl.Message{skyl.UserText("Extract the invoice number.")},
}

skyl always sends what you set#

This is one of the clearest expressions of skyl's "never silently drop data" rule: the library would rather hand you a 400 that names the problem than produce a request that quietly is not what you wrote.

Stop sequences#

req.Stop = []string{"\n\nUser:", "END"}

req.Stop = []string{"\n\nUser:", "END"}

Mapped on all four adapters — stop_sequences on Anthropic, stop on the OpenAI-format adapters, generationConfig.stopSequences on Gemini.

MaxTokens#

req.MaxTokens = 1024

req.MaxTokens = 1024

Zero means the provider's default — except on Anthropic, whose API requires the field, so that adapter supplies 4096 rather than failing a request every other provider would accept. It is the only substituted default in the library.

A negative value is rejected locally by Validate.

Hitting the cap gives you StopReason == StopMaxTokens, and the response is truncated. Treat it as incomplete rather than as a short answer.

Thinking#

type Thinking struct {
	Enabled bool
	Effort  Effort  // low, medium, high, max
}

type Thinking struct {
	Enabled bool
	Effort  Effort  // low, medium, high, max
}

A nil pointer and a zero value mean different things: nil is "provider default", &Thinking{} is "explicitly off".

This is the least uniform field in skyl, and it is worth reading the row for your provider before relying on it:

Two consequences worth stating plainly:

• On OpenAI, &Thinking{Enabled: false} does nothing. If you are turning reasoning off to control cost, it will not work there. Use ProviderOptions to send reasoning_effort directly.
• On Anthropic, Effort does nothing. The SDK's adaptive thinking config has no budget field, so there is nothing to map it onto. Reach the budget with ProviderOptions: {"thinking.budget_tokens": 4096}.

func noThinking(req *skyl.Request, provider string) {
	req.Thinking = &skyl.Thinking{Enabled: false}

	if provider == "openai" || provider == "openai-compatible" {
		// The adapter ignores Thinking unless Effort is set, so reach the wire
		// field directly. This is a shallow top-level merge, which is fine
		// here because reasoning_effort is a top-level key.
		if req.ProviderOptions == nil {
			req.ProviderOptions = map[string]any{}
		}
		req.ProviderOptions["reasoning_effort"] = "minimal"
	}
}

func noThinking(req *skyl.Request, provider string) {
	req.Thinking = &skyl.Thinking{Enabled: false}

	if provider == "openai" || provider == "openai-compatible" {
		// The adapter ignores Thinking unless Effort is set, so reach the wire
		// field directly. This is a shallow top-level merge, which is fine
		// here because reasoning_effort is a top-level key.
		if req.ProviderOptions == nil {
			req.ProviderOptions = map[string]any{}
		}
		req.ProviderOptions["reasoning_effort"] = "minimal"
	}
}

resp, err := client.Complete(ctx, req)
if err != nil {
	return err
}

if resp.StopReason == skyl.StopMaxTokens {
	return fmt.Errorf("answer truncated at %d tokens; raise MaxTokens", req.MaxTokens)
}

resp, err := client.Complete(ctx, req)
if err != nil {
	return err
}

if resp.StopReason == skyl.StopMaxTokens {
	return fmt.Errorf("answer truncated at %d tokens; raise MaxTokens", req.MaxTokens)
}