options.go

// Copyright (c) 2026 Matthew Winter
//
// This source code is licensed under the MIT license found in the LICENSE file
// in the root directory of this source tree.

package sigma

import (
	"net/http"
	"strings"
	"time"

	"github.com/wintermi/sigma/internal/headerutil"
)

const (
	// ErrorInvalidOptions indicates request options failed local validation.
	ErrorInvalidOptions ErrorCode = "invalid-options"
)

// ToolChoice identifies provider-neutral tool selection behavior.
type ToolChoice string

const (
	// ToolChoiceAuto lets the provider choose whether to call a tool.
	ToolChoiceAuto ToolChoice = "auto"
	// ToolChoiceNone prevents the provider from calling tools.
	ToolChoiceNone ToolChoice = "none"
)

// OpenAIOptions carries OpenAI-specific request options known to the root
// package without importing provider adapters.
type OpenAIOptions struct {
	ReasoningEffort              ThinkingLevel
	ReasoningSummary             string
	ServiceTier                  string
	ToolChoice                   any
	ResponseFormat               any
	TopLogprobs                  int
	SamplingParameters           map[string]any
	PromptCacheRetention         string
	ParallelToolCalls            *bool
	EnableGrammarTools           *bool
	TextVerbosity                string
	CodexWebSocketConnectTimeout *time.Duration
}

// AnthropicOptions carries Anthropic-specific request options known to the root
// package without importing provider adapters.
type AnthropicOptions struct {
	ThinkingBudgetTokens   *int
	ToolChoice             *AnthropicToolChoice
	ThinkingDisplay        AnthropicThinkingDisplay
	InterleavedThinking    *bool
	OutputFormat           any
	DisableParallelToolUse *bool
	EnableRefusalFallbacks bool
}

// AnthropicToolChoiceType identifies Anthropic Messages tool selection behavior.
type AnthropicToolChoiceType string

const (
	// AnthropicToolChoiceAuto lets Anthropic choose whether to call a tool.
	AnthropicToolChoiceAuto AnthropicToolChoiceType = "auto"
	// AnthropicToolChoiceAny requires Anthropic to call one of the supplied tools.
	AnthropicToolChoiceAny AnthropicToolChoiceType = "any"
	// AnthropicToolChoiceNone prevents Anthropic from calling tools.
	AnthropicToolChoiceNone AnthropicToolChoiceType = "none"
	// AnthropicToolChoiceTool requires Anthropic to call the named tool.
	AnthropicToolChoiceTool AnthropicToolChoiceType = "tool"
)

// AnthropicToolChoice carries Anthropic Messages tool choice controls.
type AnthropicToolChoice struct {
	Type AnthropicToolChoiceType `json:"type"`
	Name string                  `json:"name,omitempty"`
}

// AnthropicThinkingDisplay controls how Claude thinking content is returned
// when the model supports the display field.
type AnthropicThinkingDisplay string

const (
	// AnthropicThinkingDisplaySummarized requests summarized thinking text.
	AnthropicThinkingDisplaySummarized AnthropicThinkingDisplay = "summarized"
	// AnthropicThinkingDisplayOmitted asks Anthropic to omit thinking text while
	// preserving signatures for replay.
	AnthropicThinkingDisplayOmitted AnthropicThinkingDisplay = "omitted"
)

// GoogleOptions carries Google-specific request options known to the root
// package without importing provider adapters.
type GoogleOptions struct {
	ThinkingBudgetTokens *int
	ToolChoice           string
	DisableThinking      *bool
}

// MistralOptions carries Mistral-specific request options known to the root
// package without importing the provider adapter.
type MistralOptions struct {
	ToolChoice *MistralToolChoice
}

// MistralToolChoiceType identifies Mistral Conversations tool selection behavior.
type MistralToolChoiceType string

const (
	// MistralToolChoiceAuto lets Mistral choose whether to call a tool.
	MistralToolChoiceAuto MistralToolChoiceType = "auto"
	// MistralToolChoiceAny asks Mistral to call one of the supplied tools.
	MistralToolChoiceAny MistralToolChoiceType = "any"
	// MistralToolChoiceNone prevents Mistral from calling tools.
	MistralToolChoiceNone MistralToolChoiceType = "none"
	// MistralToolChoiceRequired requires Mistral to call one of the supplied tools.
	MistralToolChoiceRequired MistralToolChoiceType = "required"
	// MistralToolChoiceTool requires Mistral to call the named function.
	MistralToolChoiceTool MistralToolChoiceType = "function"
)

// MistralToolChoice carries Mistral Conversations tool choice controls.
type MistralToolChoice struct {
	Type MistralToolChoiceType `json:"type"`
	Name string                `json:"name,omitempty"`
}

// BedrockToolChoiceType identifies Bedrock Converse tool selection behavior.
type BedrockToolChoiceType string

const (
	// BedrockToolChoiceAuto lets Bedrock choose whether to call a tool.
	BedrockToolChoiceAuto BedrockToolChoiceType = "auto"
	// BedrockToolChoiceAny requires Bedrock to call one of the supplied tools.
	BedrockToolChoiceAny BedrockToolChoiceType = "any"
	// BedrockToolChoiceNone omits tools from the Bedrock request.
	BedrockToolChoiceNone BedrockToolChoiceType = "none"
	// BedrockToolChoiceTool requires Bedrock to call the named tool.
	BedrockToolChoiceTool BedrockToolChoiceType = "tool"
)

// BedrockToolChoice carries Bedrock Converse tool choice controls.
type BedrockToolChoice struct {
	Type BedrockToolChoiceType `json:"type"`
	Name string                `json:"name,omitempty"`
}

// BedrockThinkingDisplay controls how Claude thinking content is returned by
// Bedrock when the model supports the display field.
type BedrockThinkingDisplay string

const (
	// BedrockThinkingDisplaySummarized requests summarized thinking text.
	BedrockThinkingDisplaySummarized BedrockThinkingDisplay = "summarized"
	// BedrockThinkingDisplayOmitted asks Bedrock to omit thinking text while
	// preserving signatures for replay.
	BedrockThinkingDisplayOmitted BedrockThinkingDisplay = "omitted"
)

// BedrockOptions carries Bedrock-specific request options known to the root
// package without importing the provider adapter.
type BedrockOptions struct {
	ToolChoice                        *BedrockToolChoice
	BearerToken                       string
	ThinkingDisplay                   BedrockThinkingDisplay
	InterleavedThinking               *bool
	StopSequences                     []string
	TopP                              *float64
	ResponseFormat                    any
	RequestMetadata                   map[string]string
	AdditionalModelRequestFields      map[string]any
	AdditionalModelResponseFieldPaths []string
}

// StructuredOutputType identifies provider-neutral structured-output modes.
type StructuredOutputType string

const (
	// StructuredOutputJSONObject asks the provider to return any JSON object.
	StructuredOutputJSONObject StructuredOutputType = "json_object"
	// StructuredOutputJSONSchema asks the provider to return an object matching
	// the supplied JSON Schema-compatible schema.
	StructuredOutputJSONSchema StructuredOutputType = "json_schema"
)

// StructuredOutput describes a provider-neutral structured-output request.
type StructuredOutput struct {
	Type   StructuredOutputType
	Name   string
	Schema any
	Strict bool
}

// Options configures a single provider request.
//
// Client.Stream merges options in this order: client defaults, defaults from
// the selected model metadata, call options, then provider-specific extension
// values inside ProviderOptions. Provider packages may define their own helper
// option functions that populate ProviderOptions without changing this root
// package.
type Options struct {
	Temperature                  *float64
	MaxTokens                    *int
	AutomaticMaxTokensForContext *bool
	APIKey                       string
	OAuthMinimumValidity         *time.Duration
	HTTPClient                   *http.Client
	AuthResolver                 AuthResolver
	Transport                    Transport
	CacheRetention               CacheRetention
	SessionID                    string
	Headers                      map[string]string
	SuppressedHeaders            []string
	Timeout                      *time.Duration
	MaxRetries                   *int
	MaxRetryDelay                *time.Duration
	Metadata                     map[string]any
	ReasoningLevel               ThinkingLevel
	ThinkingBudgetTokens         *int
	ToolChoice                   ToolChoice
	StructuredOutput             *StructuredOutput
	TopLogprobs                  int
	ProviderOptions              map[ProviderID]map[string]any
	ProviderAuthResolvers        map[ProviderID]AuthResolver
	TextPayloadDebugHooks        []TextPayloadDebugHook
	TextResponseDebugHooks       []TextResponseDebugHook
	ImagePayloadDebugHooks       []ImagePayloadDebugHook
	ImageResponseDebugHooks      []ImageResponseDebugHook
	EmbeddingPayloadDebugHooks   []EmbeddingPayloadDebugHook
	EmbeddingResponseDebugHooks  []EmbeddingResponseDebugHook
	OpenAIOptions                *OpenAIOptions
	AnthropicOptions             *AnthropicOptions
	GoogleOptions                *GoogleOptions
	MistralOptions               *MistralOptions
	BedrockOptions               *BedrockOptions
}

// Option configures a single provider request.
type Option func(*Options)

// WithTemperature configures sampling temperature for a request.
func WithTemperature(temperature float64) Option {
	return func(options *Options) {
		options.Temperature = float64Ptr(temperature)
	}
}

// WithMaxTokens configures the maximum output tokens for a request.
func WithMaxTokens(maxTokens int) Option {
	return func(options *Options) {
		options.MaxTokens = intPtr(maxTokens)
	}
}

// WithAutomaticMaxTokensForContext configures dispatch-time max token
// budgeting from model context metadata and EstimateRequestTokens.
func WithAutomaticMaxTokensForContext(enabled bool) Option {
	return func(options *Options) {
		options.AutomaticMaxTokensForContext = boolPtr(enabled)
	}
}

// WithAPIKey configures a request-scoped API key override.
//
// API key overrides are intentionally not retained by WithDefaultOptions.
func WithAPIKey(apiKey string) Option {
	return func(options *Options) {
		options.APIKey = apiKey
	}
}

// WithOAuthMinimumValidity requires an OAuth credential to retain at least the
// requested lifetime before dispatch. It may trigger an early refresh but does
// not shorten provider-configured refresh windows.
func WithOAuthMinimumValidity(minimumValidity time.Duration) Option {
	return func(options *Options) {
		options.OAuthMinimumValidity = durationPtr(minimumValidity)
	}
}

// WithRequestHTTPClient configures an HTTP client for a text request.
//
// A non-nil request client takes precedence over configured client and provider
// fallback clients. A nil client retains the existing fallback behavior. This
// option applies to HTTP and SSE dispatch; WebSocket transports keep their
// existing dialing behavior.
func WithRequestHTTPClient(httpClient *http.Client) Option {
	return func(options *Options) {
		options.HTTPClient = httpClient
	}
}

// WithTransport configures the provider transport for a request.
func WithTransport(transport Transport) Option {
	return func(options *Options) {
		options.Transport = transport
	}
}

// WithCacheRetention configures provider-side prompt cache retention.
func WithCacheRetention(retention CacheRetention) Option {
	return func(options *Options) {
		options.CacheRetention = retention
	}
}

// WithSessionID configures a provider conversation or response session id.
func WithSessionID(sessionID string) Option {
	return func(options *Options) {
		options.SessionID = sessionID
	}
}

// WithHeader adds or replaces a request header.
func WithHeader(key, value string) Option {
	return func(options *Options) {
		options.Headers = headerutil.Merge(options.Headers, map[string]string{key: value})
	}
}

// WithHeaders adds or replaces request headers.
func WithHeaders(headers map[string]string) Option {
	return func(options *Options) {
		if len(headers) == 0 {
			return
		}
		options.Headers = headerutil.Merge(options.Headers, headers)
	}
}

// WithSuppressedHeader removes a final outgoing request header by name.
//
// Suppression applies after provider, model, and caller headers are merged.
// Credential-bearing auth headers are not suppressed.
func WithSuppressedHeader(key string) Option {
	return WithSuppressedHeaders(key)
}

// WithSuppressedHeaders removes final outgoing request headers by name.
//
// Header names are matched case-insensitively. Empty names are ignored.
func WithSuppressedHeaders(keys ...string) Option {
	return func(options *Options) {
		for _, key := range keys {
			trimmed := strings.TrimSpace(key)
			if trimmed == "" {
				continue
			}
			options.SuppressedHeaders = append(options.SuppressedHeaders, trimmed)
		}
	}
}

// WithTimeout configures the per-request provider timeout. Zero disables the
// request timeout; cancellation still follows the parent context.
func WithTimeout(timeout time.Duration) Option {
	return func(options *Options) {
		options.Timeout = durationPtr(timeout)
	}
}

// WithMaxRetries configures the maximum HTTP provider retry attempts after the
// first request. The default is DefaultMaxRetries.
func WithMaxRetries(maxRetries int) Option {
	return func(options *Options) {
		options.MaxRetries = intPtr(maxRetries)
	}
}

// WithMaxRetryDelay configures the maximum delay between HTTP provider retries,
// including provider Retry-After values. The default is DefaultMaxRetryDelay.
// Zero retries without backoff and fails any response that asks to wait.
func WithMaxRetryDelay(maxRetryDelay time.Duration) Option {
	return func(options *Options) {
		options.MaxRetryDelay = durationPtr(maxRetryDelay)
	}
}

// WithMetadata adds or replaces provider-neutral request metadata.
func WithMetadata(metadata map[string]any) Option {
	return func(options *Options) {
		if len(metadata) == 0 {
			return
		}
		if options.Metadata == nil {
			options.Metadata = make(map[string]any, len(metadata))
		}
		for key, value := range metadata {
			options.Metadata[key] = value
		}
	}
}

// WithMetadataValue adds or replaces one provider-neutral metadata value.
func WithMetadataValue(key string, value any) Option {
	return func(options *Options) {
		if options.Metadata == nil {
			options.Metadata = make(map[string]any)
		}
		options.Metadata[key] = value
	}
}

// WithReasoningLevel configures a provider-neutral reasoning level.
func WithReasoningLevel(level ThinkingLevel) Option {
	return func(options *Options) {
		options.ReasoningLevel = level
	}
}

// WithThinkingBudgetTokens configures a provider-neutral thinking budget.
func WithThinkingBudgetTokens(tokens int) Option {
	return func(options *Options) {
		options.ThinkingBudgetTokens = intPtr(tokens)
	}
}

// WithToolChoice configures provider-neutral tool selection for a request.
func WithToolChoice(choice ToolChoice) Option {
	return func(options *Options) {
		options.ToolChoice = choice
	}
}

// WithStructuredOutput requests provider-neutral structured output.
func WithStructuredOutput(output StructuredOutput) Option {
	return func(options *Options) {
		options.StructuredOutput = cloneStructuredOutput(&output)
	}
}

// WithJSONOutput asks the provider to return any JSON object.
func WithJSONOutput() Option {
	return WithStructuredOutput(StructuredOutput{Type: StructuredOutputJSONObject})
}

// WithJSONSchemaOutput asks the provider to return JSON matching schema.
func WithJSONSchemaOutput(name string, schema any, strict bool) Option {
	return WithStructuredOutput(StructuredOutput{
		Type:   StructuredOutputJSONSchema,
		Name:   name,
		Schema: schema,
		Strict: strict,
	})
}

// WithTopLogprobs requests top token log probabilities when the provider API
// supports them.
func WithTopLogprobs(top int) Option {
	return func(options *Options) {
		options.TopLogprobs = top
	}
}

// WithProviderOptions adds or replaces advanced provider-specific values.
func WithProviderOptions(provider ProviderID, values map[string]any) Option {
	return func(options *Options) {
		if len(values) == 0 {
			return
		}
		if options.ProviderOptions == nil {
			options.ProviderOptions = make(map[ProviderID]map[string]any)
		}
		if options.ProviderOptions[provider] == nil {
			options.ProviderOptions[provider] = make(map[string]any, len(values))
		}
		for key, value := range values {
			options.ProviderOptions[provider][key] = value
		}
	}
}

// WithProviderOption adds or replaces one advanced provider-specific value.
func WithProviderOption(provider ProviderID, key string, value any) Option {
	return func(options *Options) {
		if options.ProviderOptions == nil {
			options.ProviderOptions = make(map[ProviderID]map[string]any)
		}
		if options.ProviderOptions[provider] == nil {
			options.ProviderOptions[provider] = make(map[string]any)
		}
		options.ProviderOptions[provider][key] = value
	}
}

// WithProviderAuthResolver configures a provider-specific credential callback.
func WithProviderAuthResolver(provider ProviderID, resolver AuthResolver) Option {
	return func(options *Options) {
		if resolver == nil {
			return
		}
		if options.ProviderAuthResolvers == nil {
			options.ProviderAuthResolvers = make(map[ProviderID]AuthResolver)
		}
		options.ProviderAuthResolvers[provider] = resolver
	}
}

// WithOpenAIOptions configures known OpenAI-specific request options.
func WithOpenAIOptions(openAIOptions OpenAIOptions) Option {
	return func(options *Options) {
		options.OpenAIOptions = cloneOpenAIOptions(&openAIOptions)
	}
}

// WithAnthropicOptions configures known Anthropic-specific request options.
func WithAnthropicOptions(anthropicOptions AnthropicOptions) Option {
	return func(options *Options) {
		options.AnthropicOptions = cloneAnthropicOptions(&anthropicOptions)
	}
}

// WithGoogleOptions configures known Google-specific request options.
func WithGoogleOptions(googleOptions GoogleOptions) Option {
	return func(options *Options) {
		options.GoogleOptions = cloneGoogleOptions(&googleOptions)
	}
}

// WithMistralOptions configures known Mistral-specific request options.
func WithMistralOptions(mistralOptions MistralOptions) Option {
	return func(options *Options) {
		options.MistralOptions = cloneMistralOptions(&mistralOptions)
	}
}

// WithBedrockOptions configures known Bedrock-specific request options.
func WithBedrockOptions(bedrockOptions BedrockOptions) Option {
	return func(options *Options) {
		options.BedrockOptions = cloneBedrockOptions(&bedrockOptions)
	}
}

func applyOptions(options Options, opts []Option) Options {
	applied := cloneOptions(options)
	for _, opt := range opts {
		if opt != nil {
			opt(&applied)
		}
	}
	return applied
}

func cloneOptions(options Options) Options {
	return Options{
		Temperature:                  cloneFloat64Ptr(options.Temperature),
		MaxTokens:                    cloneIntPtr(options.MaxTokens),
		AutomaticMaxTokensForContext: cloneBoolPtr(options.AutomaticMaxTokensForContext),
		APIKey:                       options.APIKey,
		OAuthMinimumValidity:         cloneDurationPtr(options.OAuthMinimumValidity),
		HTTPClient:                   options.HTTPClient,
		AuthResolver:                 options.AuthResolver,
		Transport:                    options.Transport,
		CacheRetention:               options.CacheRetention,
		SessionID:                    options.SessionID,
		Headers:                      headerutil.Merge(nil, options.Headers),
		SuppressedHeaders:            append([]string(nil), options.SuppressedHeaders...),
		Timeout:                      cloneDurationPtr(options.Timeout),
		MaxRetries:                   cloneIntPtr(options.MaxRetries),
		MaxRetryDelay:                cloneDurationPtr(options.MaxRetryDelay),
		Metadata:                     copyStringAnyMap(options.Metadata),
		ReasoningLevel:               options.ReasoningLevel,
		ThinkingBudgetTokens:         cloneIntPtr(options.ThinkingBudgetTokens),
		ToolChoice:                   options.ToolChoice,
		StructuredOutput:             cloneStructuredOutput(options.StructuredOutput),
		TopLogprobs:                  options.TopLogprobs,
		ProviderOptions:              copyProviderOptions(options.ProviderOptions),
		ProviderAuthResolvers:        copyProviderAuthResolvers(options.ProviderAuthResolvers),
		TextPayloadDebugHooks:        append([]TextPayloadDebugHook(nil), options.TextPayloadDebugHooks...),
		TextResponseDebugHooks:       append([]TextResponseDebugHook(nil), options.TextResponseDebugHooks...),
		ImagePayloadDebugHooks:       append([]ImagePayloadDebugHook(nil), options.ImagePayloadDebugHooks...),
		ImageResponseDebugHooks:      append([]ImageResponseDebugHook(nil), options.ImageResponseDebugHooks...),
		EmbeddingPayloadDebugHooks:   append([]EmbeddingPayloadDebugHook(nil), options.EmbeddingPayloadDebugHooks...),
		EmbeddingResponseDebugHooks:  append([]EmbeddingResponseDebugHook(nil), options.EmbeddingResponseDebugHooks...),
		OpenAIOptions:                cloneOpenAIOptions(options.OpenAIOptions),
		AnthropicOptions:             cloneAnthropicOptions(options.AnthropicOptions),
		GoogleOptions:                cloneGoogleOptions(options.GoogleOptions),
		MistralOptions:               cloneMistralOptions(options.MistralOptions),
		BedrockOptions:               cloneBedrockOptions(options.BedrockOptions),
	}
}

func copyProviderOptions(values map[ProviderID]map[string]any) map[ProviderID]map[string]any {
	if len(values) == 0 {
		return nil
	}
	copied := make(map[ProviderID]map[string]any, len(values))
	for provider, providerValues := range values {
		copied[provider] = copyStringAnyMap(providerValues)
	}
	return copied
}

func copyProviderAuthResolvers(values map[ProviderID]AuthResolver) map[ProviderID]AuthResolver {
	if len(values) == 0 {
		return nil
	}
	copied := make(map[ProviderID]AuthResolver, len(values))
	for provider, resolver := range values {
		copied[provider] = resolver
	}
	return copied
}

func cloneOpenAIOptions(options *OpenAIOptions) *OpenAIOptions {
	if options == nil {
		return nil
	}
	copied := *options
	copied.ParallelToolCalls = cloneBoolPtr(options.ParallelToolCalls)
	copied.EnableGrammarTools = cloneBoolPtr(options.EnableGrammarTools)
	copied.CodexWebSocketConnectTimeout = cloneDurationPtr(options.CodexWebSocketConnectTimeout)
	copied.SamplingParameters = copyStringAnyMap(options.SamplingParameters)
	return &copied
}

func cloneAnthropicOptions(options *AnthropicOptions) *AnthropicOptions {
	if options == nil {
		return nil
	}
	copied := *options
	copied.ThinkingBudgetTokens = cloneIntPtr(options.ThinkingBudgetTokens)
	if options.ToolChoice != nil {
		toolChoice := *options.ToolChoice
		copied.ToolChoice = &toolChoice
	}
	copied.InterleavedThinking = cloneBoolPtr(options.InterleavedThinking)
	copied.OutputFormat = cloneAnyValue(options.OutputFormat)
	copied.DisableParallelToolUse = cloneBoolPtr(options.DisableParallelToolUse)
	return &copied
}

func cloneStructuredOutput(output *StructuredOutput) *StructuredOutput {
	if output == nil {
		return nil
	}
	copied := *output
	copied.Schema = cloneAnyValue(output.Schema)
	return &copied
}

func cloneGoogleOptions(options *GoogleOptions) *GoogleOptions {
	if options == nil {
		return nil
	}
	copied := *options
	copied.ThinkingBudgetTokens = cloneIntPtr(options.ThinkingBudgetTokens)
	copied.DisableThinking = cloneBoolPtr(options.DisableThinking)
	return &copied
}

func cloneMistralOptions(options *MistralOptions) *MistralOptions {
	if options == nil {
		return nil
	}
	copied := *options
	if options.ToolChoice != nil {
		toolChoice := *options.ToolChoice
		copied.ToolChoice = &toolChoice
	}
	return &copied
}

func cloneBedrockOptions(options *BedrockOptions) *BedrockOptions {
	if options == nil {
		return nil
	}
	copied := *options
	if options.ToolChoice != nil {
		toolChoice := *options.ToolChoice
		copied.ToolChoice = &toolChoice
	}
	copied.InterleavedThinking = cloneBoolPtr(options.InterleavedThinking)
	copied.StopSequences = append([]string(nil), options.StopSequences...)
	copied.TopP = cloneFloat64Ptr(options.TopP)
	copied.ResponseFormat = cloneAnyValue(options.ResponseFormat)
	copied.RequestMetadata = copyStringStringMap(options.RequestMetadata)
	copied.AdditionalModelRequestFields = copyStringAnyMap(options.AdditionalModelRequestFields)
	copied.AdditionalModelResponseFieldPaths = append([]string(nil), options.AdditionalModelResponseFieldPaths...)
	return &copied
}

func intPtr(value int) *int {
	return &value
}

func float64Ptr(value float64) *float64 {
	return &value
}

func durationPtr(value time.Duration) *time.Duration {
	return &value
}

func boolPtr(value bool) *bool {
	return &value
}

func cloneIntPtr(value *int) *int {
	if value == nil {
		return nil
	}
	copied := *value
	return &copied
}

func cloneFloat64Ptr(value *float64) *float64 {
	if value == nil {
		return nil
	}
	copied := *value
	return &copied
}

func cloneDurationPtr(value *time.Duration) *time.Duration {
	if value == nil {
		return nil
	}
	copied := *value
	return &copied
}