Merge pull request #1318 from trheyi/main

Refactor connector settings to model capabilities

Author: trheyi

agent/assistant/agent.go

@@ -154,46 +154,46 @@ func (ast *Assistant) getConnectorCapabilities(connectorID string) *context.Mode
 		Streaming: &falseVal,
 	}
 
-	// Get connector setting from global settings
-	setting, exists := connectorSettings[connectorID]
+	// Get model capabilities from global configuration
+	modelCaps, exists := modelCapabilities[connectorID]
 	if !exists {
-		// Return default capabilities if connector not found in settings
+		// Return default capabilities if model not found in configuration
 		return capabilities
 	}
 
-	// Update capabilities based on connector settings
-	if setting.Vision {
+	// Update capabilities based on model configuration
+	if modelCaps.Vision {
 		v := true
 		capabilities.Vision = &v
 	}
 
 	// Handle both Tools (deprecated) and ToolCalls
-	if setting.ToolCalls || setting.Tools {
+	if modelCaps.ToolCalls || modelCaps.Tools {
 		v := true
 		capabilities.ToolCalls = &v
 	}
 
-	if setting.Audio {
+	if modelCaps.Audio {
 		v := true
 		capabilities.Audio = &v
 	}
 
-	if setting.Reasoning {
+	if modelCaps.Reasoning {
 		v := true
 		capabilities.Reasoning = &v
 	}
 
-	if setting.Streaming {
+	if modelCaps.Streaming {
 		v := true
 		capabilities.Streaming = &v
 	}
 
-	if setting.JSON {
+	if modelCaps.JSON {
 		v := true
 		capabilities.JSON = &v
 	}
 
-	if setting.Multimodal {
+	if modelCaps.Multimodal {
 		v := true
 		capabilities.Multimodal = &v
 	}

agent/assistant/api.go

@@ -770,7 +770,7 @@ func (ast *Assistant) withOptions(options map[string]interface{}) map[string]int
 
 	// Add tool_calls
 	if ast.Tools != nil && ast.Tools.Tools != nil && len(ast.Tools.Tools) > 0 {
-		if settings, has := connectorSettings[ast.Connector]; has && settings.Tools {
+		if capabilities, has := modelCapabilities[ast.Connector]; has && capabilities.Tools {
 			options["tools"] = ast.Tools.Tools
 			if options["tool_choice"] == nil {
 				options["tool_choice"] = "auto"
@@ -794,8 +794,8 @@ func (ast *Assistant) withPrompts(messages []chatMessage.Message) []chatMessage.
 
 	// Add tool_calls
 	if ast.Tools != nil && ast.Tools.Tools != nil && len(ast.Tools.Tools) > 0 {
-		settings, has := connectorSettings[ast.Connector]
-		if !has || !settings.Tools {
+		capabilities, has := modelCapabilities[ast.Connector]
+		if !has || !capabilities.Tools {
 			// Convert store tools to runtime tools if not already done
 			if ast.runtimeTools == nil {
 				runtimeTools, err := ToRuntimeTools(ast.Tools.Tools)

agent/assistant/load.go

@@ -27,7 +27,7 @@ import (
 var loaded = NewCache(200) // 200 is the default capacity
 var storage store.Store = nil
 var search interface{} = nil
-var connectorSettings map[string]ConnectorSetting = map[string]ConnectorSetting{}
+var modelCapabilities map[string]ModelCapabilities = map[string]ModelCapabilities{}
 var vision *agentvision.Vision = nil
 var defaultConnector string = ""   // default connector
 var globalUses *context.Uses = nil // global uses configuration from agent.yml
@@ -137,9 +137,9 @@ func SetVision(v *agentvision.Vision) {
 	vision = v
 }
 
-// SetConnectorSettings set the connector settings
-func SetConnectorSettings(settings map[string]ConnectorSetting) {
-	connectorSettings = settings
+// SetModelCapabilities set the model capabilities configuration
+func SetModelCapabilities(capabilities map[string]ModelCapabilities) {
+	modelCapabilities = capabilities
 }
 
 // SetConnector set the connector

agent/assistant/types.go

@@ -108,9 +108,9 @@ type Assistant struct {
 	runtimeTools []Tool // Converted tools for business logic (OpenAI format)
 }
 
-// ConnectorSetting the connector setting
-// Defines the capabilities of a connector/model
-type ConnectorSetting struct {
+// ModelCapabilities defines the capabilities of a language model
+// This configuration is loaded from agent/models.yml
+type ModelCapabilities struct {
 	Vision     bool `json:"vision,omitempty" yaml:"vision,omitempty"`         // Supports vision/image input
 	Tools      bool `json:"tools,omitempty" yaml:"tools,omitempty"`           // Supports tool/function calling (deprecated, use ToolCalls)
 	ToolCalls  bool `json:"tool_calls,omitempty" yaml:"tool_calls,omitempty"` // Supports tool/function calling

agent/context/openapi.go

@@ -122,13 +122,12 @@ func GetAssistantID(c *gin.Context, req *CompletionRequest) (string, error) {
 	}
 
 	if model != "" {
-		// Split by "-" and get the last field
-		parts := strings.Split(model, "-")
-		lastField := strings.TrimSpace(parts[len(parts)-1])
-
-		// Check if it has yao_ prefix
-		if strings.HasPrefix(lastField, "yao_") {
-			assistantID := strings.TrimPrefix(lastField, "yao_")
+		// Parse model ID using the same logic as ParseModelID
+		// Expected format: [prefix-]assistantName-model-yao_assistantID
+		// Find the last occurrence of "-yao_"
+		parts := strings.Split(model, "-yao_")
+		if len(parts) >= 2 {
+			assistantID := parts[len(parts)-1]
 			if assistantID != "" {
 				return assistantID, nil
 			}

agent/context/types_llm.go

@@ -12,13 +12,14 @@ type Uses struct {
 // ModelCapabilities defines the capabilities of a language model
 // Used by LLM to select appropriate provider and validate requests
 type ModelCapabilities struct {
-	Vision     *bool `json:"vision,omitempty"`     // Supports vision/image input
-	ToolCalls  *bool `json:"tool_calls,omitempty"` // Supports tool/function calling
-	Audio      *bool `json:"audio,omitempty"`      // Supports audio input/output
-	Reasoning  *bool `json:"reasoning,omitempty"`  // Supports reasoning/thinking mode (o1, DeepSeek R1)
-	Streaming  *bool `json:"streaming,omitempty"`  // Supports streaming responses
-	JSON       *bool `json:"json,omitempty"`       // Supports JSON mode
-	Multimodal *bool `json:"multimodal,omitempty"` // Supports multimodal input (text + images + audio)
+	Vision                *bool `json:"vision,omitempty"`                 // Supports vision/image input
+	ToolCalls             *bool `json:"tool_calls,omitempty"`             // Supports tool/function calling
+	Audio                 *bool `json:"audio,omitempty"`                  // Supports audio input/output
+	Reasoning             *bool `json:"reasoning,omitempty"`              // Supports reasoning/thinking mode (o1, DeepSeek R1)
+	Streaming             *bool `json:"streaming,omitempty"`              // Supports streaming responses
+	JSON                  *bool `json:"json,omitempty"`                   // Supports JSON mode
+	Multimodal            *bool `json:"multimodal,omitempty"`             // Supports multimodal input (text + images + audio)
+	TemperatureAdjustable *bool `json:"temperature_adjustable,omitempty"` // Supports temperature adjustment (reasoning models typically don't)
 }
 
 // CompletionOptions the completion request options

agent/llm/adapters/reasoning.go

@@ -16,45 +16,83 @@ const (
 
 // ReasoningAdapter handles reasoning content capability
 // - Manages reasoning_effort parameter (o1, GPT-5)
+// - Manages temperature parameter constraints (reasoning models typically require temperature=1)
 // - Extracts reasoning_tokens from usage
 // - Parses visible reasoning content (DeepSeek R1)
 type ReasoningAdapter struct {
 	*BaseAdapter
-	format         ReasoningFormat
-	supportsEffort bool // Whether the model supports reasoning_effort parameter
+	format              ReasoningFormat
+	supportsEffort      bool // Whether the model supports reasoning_effort parameter
+	supportsTemperature bool // Whether the model supports temperature adjustment
 }
 
 // NewReasoningAdapter creates a new reasoning adapter
-func NewReasoningAdapter(format ReasoningFormat) *ReasoningAdapter {
+// If cap.TemperatureAdjustable is provided, it overrides the default behavior
+func NewReasoningAdapter(format ReasoningFormat, cap *context.ModelCapabilities) *ReasoningAdapter {
 	supportsEffort := false
+	supportsTemperature := true
 
-	// Only OpenAI o1 and GPT-5 support reasoning_effort parameter
-	if format == ReasoningFormatOpenAI || format == ReasoningFormatGPT5 {
+	// Set defaults based on reasoning format
+	switch format {
+	case ReasoningFormatOpenAI, ReasoningFormatGPT5:
+		// OpenAI o1 and GPT-5: support reasoning_effort, but NOT temperature adjustment
 		supportsEffort = true
+		supportsTemperature = false
+	case ReasoningFormatDeepSeek:
+		// DeepSeek R1: no reasoning_effort, no temperature adjustment
+		supportsEffort = false
+		supportsTemperature = false
+	case ReasoningFormatNone:
+		// Non-reasoning models: no reasoning_effort, but support temperature
+		supportsEffort = false
+		supportsTemperature = true
+	}
+
+	// Override with explicit capability if provided
+	if cap != nil && cap.TemperatureAdjustable != nil {
+		supportsTemperature = *cap.TemperatureAdjustable
 	}
 
 	return &ReasoningAdapter{
-		BaseAdapter:    NewBaseAdapter("ReasoningAdapter"),
-		format:         format,
-		supportsEffort: supportsEffort,
+		BaseAdapter:         NewBaseAdapter("ReasoningAdapter"),
+		format:              format,
+		supportsEffort:      supportsEffort,
+		supportsTemperature: supportsTemperature,
 	}
 }
 
-// PreprocessOptions handles reasoning_effort parameter
+// PreprocessOptions handles reasoning_effort and temperature parameters
 func (a *ReasoningAdapter) PreprocessOptions(options *context.CompletionOptions) (*context.CompletionOptions, error) {
 	if options == nil {
 		return options, nil
 	}
 
-	// If model doesn't support reasoning_effort, remove it
-	if !a.supportsEffort && options.ReasoningEffort != nil {
+	newOptions := *options
+	modified := false
+
+	// 1. Handle reasoning_effort parameter
+	if !a.supportsEffort && newOptions.ReasoningEffort != nil {
 		// Model doesn't support reasoning_effort, remove the parameter
-		newOptions := *options
 		newOptions.ReasoningEffort = nil
+		modified = true
+	}
+
+	// 2. Handle temperature parameter
+	if !a.supportsTemperature && newOptions.Temperature != nil {
+		currentTemp := *newOptions.Temperature
+		if currentTemp != 1.0 {
+			// Model doesn't support temperature adjustment, reset to default (1.0)
+			defaultTemp := 1.0
+			newOptions.Temperature = &defaultTemp
+			modified = true
+		}
+	}
+
+	if modified {
 		return &newOptions, nil
 	}
 
-	// If model supports reasoning_effort, keep it as-is (user can set "low", "medium", or "high")
+	// No modifications needed
 	return options, nil
 }
 

agent/llm/providers/openai/openai.go

@@ -141,16 +141,16 @@ func buildAdapters(cap *context.ModelCapabilities) []adapters.CapabilityAdapter
 		result = append(result, adapters.NewAudioAdapter(*cap.Audio))
 	}
 
-	// Reasoning adapter (always add to handle reasoning_effort parameter)
+	// Reasoning adapter (always add to handle reasoning_effort and temperature parameters)
 	// Even if the model doesn't support reasoning, we need the adapter to strip reasoning_effort
 	if cap.Reasoning != nil {
 		if *cap.Reasoning {
 			// Detect reasoning format based on capabilities
 			format := detectReasoningFormat(cap)
-			result = append(result, adapters.NewReasoningAdapter(format))
+			result = append(result, adapters.NewReasoningAdapter(format, cap))
 		} else {
 			// Model doesn't support reasoning, use None format to strip reasoning parameters
-			result = append(result, adapters.NewReasoningAdapter(adapters.ReasoningFormatNone))
+			result = append(result, adapters.NewReasoningAdapter(adapters.ReasoningFormatNone, cap))
 		}
 	}