feat: expose provider options

Author: kujtimiihoxha

anthropic/anthropic.go

@@ -118,7 +118,7 @@ func (a languageModel) Provider() string {
 
 func (a languageModel) prepareParams(call ai.Call) (*anthropic.MessageNewParams, []ai.CallWarning, error) {
 	params := &anthropic.MessageNewParams{}
-	providerOptions := &providerOptions{}
+	providerOptions := &ProviderOptions{}
 	if v, ok := call.ProviderOptions["anthropic"]; ok {
 		err := ai.ParseOptions(v, providerOptions)
 		if err != nil {
@@ -217,19 +217,19 @@ func (a languageModel) prepareParams(call ai.Call) (*anthropic.MessageNewParams,
 	return params, warnings, nil
 }
 
-func getCacheControl(providerOptions ai.ProviderOptions) *cacheControlProviderOptions {
+func getCacheControl(providerOptions ai.ProviderOptions) *CacheControlProviderOptions {
 	if anthropicOptions, ok := providerOptions["anthropic"]; ok {
 		if cacheControl, ok := anthropicOptions["cache_control"]; ok {
 			if cc, ok := cacheControl.(map[string]any); ok {
-				cacheControlOption := &cacheControlProviderOptions{}
+				cacheControlOption := &CacheControlProviderOptions{}
 				err := ai.ParseOptions(cc, cacheControlOption)
 				if err != nil {
 					return cacheControlOption
 				}
 			}
 		} else if cacheControl, ok := anthropicOptions["cacheControl"]; ok {
 			if cc, ok := cacheControl.(map[string]any); ok {
-				cacheControlOption := &cacheControlProviderOptions{}
+				cacheControlOption := &CacheControlProviderOptions{}
 				err := ai.ParseOptions(cc, cacheControlOption)
 				if err != nil {
 					return cacheControlOption
@@ -240,9 +240,9 @@ func getCacheControl(providerOptions ai.ProviderOptions) *cacheControlProviderOp
 	return nil
 }
 
-func getReasoningMetadata(providerOptions ai.ProviderOptions) *reasoningMetadata {
+func getReasoningMetadata(providerOptions ai.ProviderOptions) *ReasoningMetadata {
 	if anthropicOptions, ok := providerOptions["anthropic"]; ok {
-		reasoningMetadata := &reasoningMetadata{}
+		reasoningMetadata := &ReasoningMetadata{}
 		err := ai.ParseOptions(anthropicOptions, reasoningMetadata)
 		if err != nil {
 			return reasoningMetadata

anthropic/provider_options.go

@@ -1,20 +1,20 @@
 package anthropic
 
-type providerOptions struct {
+type ProviderOptions struct {
 	SendReasoning          *bool                   `json:"send_reasoning,omitempty"`
-	Thinking               *thinkingProviderOption `json:"thinking,omitempty"`
+	Thinking               *ThinkingProviderOption `json:"thinking,omitempty"`
 	DisableParallelToolUse *bool                   `json:"disable_parallel_tool_use,omitempty"`
 }
 
-type thinkingProviderOption struct {
+type ThinkingProviderOption struct {
 	BudgetTokens int64 `json:"budget_tokens"`
 }
 
-type reasoningMetadata struct {
+type ReasoningMetadata struct {
 	Signature    string `json:"signature"`
 	RedactedData string `json:"redacted_data"`
 }
 
-type cacheControlProviderOptions struct {
+type CacheControlProviderOptions struct {
 	Type string `json:"type"`
 }

openai/openai.go

@@ -145,7 +145,7 @@ func (o languageModel) Provider() string {
 func (o languageModel) prepareParams(call ai.Call) (*openai.ChatCompletionNewParams, []ai.CallWarning, error) {
 	params := &openai.ChatCompletionNewParams{}
 	messages, warnings := toPrompt(call.Prompt)
-	providerOptions := &providerOptions{}
+	providerOptions := &ProviderOptions{}
 	if v, ok := call.ProviderOptions["openai"]; ok {
 		err := ai.ParseOptions(v, providerOptions)
 		if err != nil {
@@ -239,13 +239,13 @@ func (o languageModel) prepareParams(call ai.Call) (*openai.ChatCompletionNewPar
 
 	if providerOptions.ReasoningEffort != nil {
 		switch *providerOptions.ReasoningEffort {
-		case reasoningEffortMinimal:
+		case ReasoningEffortMinimal:
 			params.ReasoningEffort = shared.ReasoningEffortMinimal
-		case reasoningEffortLow:
+		case ReasoningEffortLow:
 			params.ReasoningEffort = shared.ReasoningEffortLow
-		case reasoningEffortMedium:
+		case ReasoningEffortMedium:
 			params.ReasoningEffort = shared.ReasoningEffortMedium
-		case reasoningEffortHigh:
+		case ReasoningEffortHigh:
 			params.ReasoningEffort = shared.ReasoningEffortHigh
 		default:
 			return nil, nil, fmt.Errorf("reasoning model `%s` not supported", *providerOptions.ReasoningEffort)

openai/provider_options.go

@@ -1,21 +1,21 @@
 package openai
 
-type reasoningEffort string
+type ReasoningEffort string
 
 const (
-	reasoningEffortMinimal reasoningEffort = "minimal"
-	reasoningEffortLow     reasoningEffort = "low"
-	reasoningEffortMedium  reasoningEffort = "medium"
-	reasoningEffortHigh    reasoningEffort = "high"
+	ReasoningEffortMinimal ReasoningEffort = "minimal"
+	ReasoningEffortLow     ReasoningEffort = "low"
+	ReasoningEffortMedium  ReasoningEffort = "medium"
+	ReasoningEffortHigh    ReasoningEffort = "high"
 )
 
-type providerOptions struct {
+type ProviderOptions struct {
 	LogitBias           map[string]int64 `json:"logit_bias"`
 	LogProbs            *bool            `json:"log_probes"`
 	TopLogProbs         *int64           `json:"top_log_probs"`
 	ParallelToolCalls   *bool            `json:"parallel_tool_calls"`
 	User                *string          `json:"user"`
-	ReasoningEffort     *reasoningEffort `json:"reasoning_effort"`
+	ReasoningEffort     *ReasoningEffort `json:"reasoning_effort"`
 	MaxCompletionTokens *int64           `json:"max_completion_tokens"`
 	TextVerbosity       *string          `json:"text_verbosity"`
 	Prediction          map[string]any   `json:"prediction"`