RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
feat(go-models): migrate batch 1 model drivers to unified handlers (#17696)
jay77721194f75f4017f
diff --git a/internal/entity/models/302ai.go b/internal/entity/models/302ai.goindex 2f3b4e1769..8d12eb49e2 100644--- a/internal/entity/models/302ai.go+++ b/internal/entity/models/302ai.go@@ -75,7 +75,6 @@ func (a *AI302Model) ChatWithMessages(ctx context.Context, modelName string, mesif err := a.baseModel.APIConfigCheck(apiConfig); err != nil {return nil, err}- apiKey := strings.TrimSpace(*apiConfig.ApiKey)if strings.TrimSpace(modelName) == "" {return nil, fmt.Errorf("model name is required")}@@ -113,90 +112,18 @@ func (a *AI302Model) ChatWithMessages(ctx context.Context, modelName string, mes}}- jsonData, err := json.Marshal(reqBody)- if err != nil {- return nil, fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))- if err != nil {- return nil, fmt.Errorf("failed to create request: %w", err)- }-- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", apiKey))-- resp, err := a.baseModel.httpClient.Do(req)- if err != nil {- return nil, fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- body, err := io.ReadAll(resp.Body)+ body, err := a.baseModel.doRequest(ctx, url, apiConfig, reqBody, nonStreamCallTimeout)if err != nil {- return nil, fmt.Errorf("failed to read response: %w", err)- }-- if resp.StatusCode != http.StatusOK {- return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))- }-- // Parse response- var result map[string]interface{}- if err = json.Unmarshal(body, &result); err != nil {- return nil, fmt.Errorf("failed to parse response: %w", err)- }-- choices, ok := result["choices"].([]interface{})- if !ok || len(choices) == 0 {- return nil, fmt.Errorf("no choices in response")- }-- firstChoice, ok := choices[0].(map[string]interface{})- if !ok {- return nil, fmt.Errorf("invalid choice format")- }-- messageMap, ok := firstChoice["message"].(map[string]interface{})- if !ok {- return nil, fmt.Errorf("invalid message format")- }-- content, ok := messageMap["content"].(string)- toolCalls := extractToolCalls(messageMap)- if !ok && len(toolCalls) == 0 {- return nil, fmt.Errorf("invalid content format")- }-- var reasonContent string- if chatModelConfig != nil && chatModelConfig.Thinking != nil && *chatModelConfig.Thinking {- reasonContent, ok = messageMap["reasoning_content"].(string)- if !ok {- return nil, fmt.Errorf("invalid content format")- }- // if first char of reasonContent is \n remove the '\n'- if reasonContent != "" && reasonContent[0] == '\n' {- reasonContent = reasonContent[1:]- }- }-- chatResponse := &ChatResponse{- Answer: &content,- ReasonContent: &reasonContent,- ToolCalls: toolCalls,+ return nil, err}- return chatResponse, nil+ return HandleNonStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig)}func (a *AI302Model) ChatStreamlyWithSender(ctx context.Context, modelName string, messages []Message, apiConfig *APIConfig, modelConfig *ChatConfig, modelUsage *common.ModelUsage, sender func(*string, *string) error) error {if err := a.baseModel.APIConfigCheck(apiConfig); err != nil {return err}- apiKey := strings.TrimSpace(*apiConfig.ApiKey)if strings.TrimSpace(modelName) == "" {return fmt.Errorf("model name is required")}@@ -237,77 +164,11 @@ func (a *AI302Model) ChatStreamlyWithSender(ctx context.Context, modelName strin}}- jsonData, err := json.Marshal(reqBody)- if err != nil {- return fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, streamCallTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))- if err != nil {- return fmt.Errorf("failed to create request: %w", err)- }-- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", apiKey))- req.Header.Set("Accept", "text/event-stream")-- resp, err := a.baseModel.httpClient.Do(req)- if err != nil {- return fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- if resp.StatusCode != http.StatusOK {- body, _ := io.ReadAll(resp.Body)- return fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))- }-- accumulatedToolCalls := make(map[int]map[string]any)- if _, err = ParseSSEStream[map[string]interface{}](resp.Body, func(event map[string]interface{}) error {- choices, ok := event["choices"].([]interface{})- if !ok || len(choices) == 0 {- return nil- }-- firstChoice, ok := choices[0].(map[string]interface{})- if !ok {- return nil- }-- delta, ok := firstChoice["delta"].(map[string]interface{})- if !ok {- return nil- }-- accumulateToolCallDeltas(delta, accumulatedToolCalls)-- reasoningContent, ok := delta["reasoning_content"].(string)- if ok && reasoningContent != "" {- if err = sender(nil, &reasoningContent); err != nil {- return err- }- }-- content, ok := delta["content"].(string)- if ok && content != "" {- if err = sender(&content, nil); err != nil {- return err- }- }-- return nil- }); err != nil {- return fmt.Errorf("failed to scan response body: %w", err)- }-- setSortedToolCallsResult(modelConfig, accumulatedToolCalls)+ reqBody["stream_options"] = map[string]interface{}{"include_usage": true}- // Send [DONE] marker for OpenAI compatibility- endOfStream := "[DONE]"- return sender(&endOfStream, nil)+ return a.baseModel.doStreamRequest(ctx, url, apiConfig, reqBody, streamCallTimeout, func(body io.ReadCloser) error {+ return HandleStreamingResponse(body, modelUsage, modelConfig, OpenAIParserConfig, sender)+ })}func (a *AI302Model) Embed(ctx context.Context, modelName *string, texts []string, apiConfig *APIConfig, embeddingConfig *EmbeddingConfig, modelUsage *common.ModelUsage) ([]EmbeddingData, error) {diff --git a/internal/entity/models/aliyun.go b/internal/entity/models/aliyun.goindex 6dcad3dff5..8d74744c3d 100644--- a/internal/entity/models/aliyun.go+++ b/internal/entity/models/aliyun.go@@ -52,37 +52,6 @@ func (a *AliyunModel) Name() string {return "Tongyi-Qianwen"}-// AliyunChatResponse mirrors DashScope's OpenAI-compatible chat response.-type AliyunChatResponse struct {- ID string `json:"id"`- Object string `json:"object"`- Created int64 `json:"created"`- Model string `json:"model"`- Choices []struct {- FinishReason string `json:"finish_reason"`- Index int `json:"index"`- Logprobs any `json:"logprobs"`- Message struct {- Content string `json:"content"`- ReasoningContent string `json:"reasoning_content"`- Role string `json:"role"`- ToolCalls []map[string]any `json:"tool_calls"`- } `json:"message"`- } `json:"choices"`- SystemFingerprint string `json:"system_fingerprint"`- Usage struct {- CompletionTokens int `json:"completion_tokens"`- PromptTokens int `json:"prompt_tokens"`- TotalTokens int `json:"total_tokens"`- CompletionTokensDetails struct {- ReasoningTokens int `json:"reasoning_tokens"`- } `json:"completion_tokens_details"`- PromptTokensDetails struct {- CachedTokens int `json:"cached_tokens"`- } `json:"prompt_tokens_details"`- } `json:"usage"`-}-func (a *AliyunModel) ChatWithMessages(ctx context.Context, modelName string, messages []Message, apiConfig *APIConfig, chatModelConfig *ChatConfig, modelUsage *common.ModelUsage) (*ChatResponse, error) {if err := a.baseModel.APIConfigCheck(apiConfig); err != nil {return nil, err@@ -121,78 +90,12 @@ func (a *AliyunModel) ChatWithMessages(ctx context.Context, modelName string, me// enabled by the user, matching Python's chat_model.py behavior.applyQwen3ThinkingDefault(modelName, reqBody)- jsonData, err := json.Marshal(reqBody)- if err != nil {- return nil, fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))- if err != nil {- return nil, fmt.Errorf("failed to create request: %w", err)- }-- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))-- resp, err := a.baseModel.httpClient.Do(req)- if err != nil {- return nil, fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- body, err := io.ReadAll(resp.Body)+ body, err := a.baseModel.doRequest(ctx, url, apiConfig, reqBody, nonStreamCallTimeout)if err != nil {- return nil, fmt.Errorf("failed to read response: %w", err)- }-- if resp.StatusCode != http.StatusOK {- return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))+ return nil, err}- return parseChatCompletionResponse(body, chatModelConfig, modelUsage, func(body []byte, chatConfig *ChatConfig) (chatResponseParts, error) {- var result AliyunChatResponse- if err := json.Unmarshal(body, &result); err != nil {- return chatResponseParts{}, fmt.Errorf("failed to parse response: %w", err)- }- if len(result.Choices) == 0 {- return chatResponseParts{}, fmt.Errorf("no choices in response")- }-- choice := &result.Choices[0]- content := choice.Message.Content- if content == "" && len(choice.Message.ToolCalls) == 0 {- return chatResponseParts{}, fmt.Errorf("response contains neither content nor tool calls")- }- reasonContent := ""- if chatConfig != nil && chatConfig.Thinking != nil && *chatConfig.Thinking {- reasonContent = choice.Message.ReasoningContent- if reasonContent == "" {- reasoning, answer := GetThinkingAndAnswer(chatConfig.ModelClass, &content)- if reasoning != nil {- reasonContent = *reasoning- content = *answer- }- }- if reasonContent != "" && reasonContent[0] == '\n' {- reasonContent = reasonContent[1:]- }- }-- return chatResponseParts{- RequestID: result.ID,- Content: &content,- ReasonContent: &reasonContent,- ToolCalls: choice.Message.ToolCalls,- Usage: &TokenUsage{- PromptTokens: result.Usage.PromptTokens,- CompletionTokens: result.Usage.CompletionTokens,- TotalTokens: result.Usage.TotalTokens,- },- }, nil- })+ return HandleNonStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig)}// ChatStreamlyWithSender sends messages and streams response via sender function (best performance, no channel)@@ -235,96 +138,9 @@ func (a *AliyunModel) ChatStreamlyWithSender(ctx context.Context, modelName stri// enabled by the user, matching Python's chat_model.py behavior.applyQwen3ThinkingDefault(modelName, reqBody)- jsonData, err := json.Marshal(reqBody)- if err != nil {- return fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, streamCallTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))- if err != nil {- return fmt.Errorf("failed to create request: %w", err)- }-- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))-- resp, err := a.baseModel.httpClient.Do(req)- if err != nil {- return fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- if resp.StatusCode != http.StatusOK {- body, _ := io.ReadAll(resp.Body)- return fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))- }-- sawTerminal := false- accumulatedToolCalls := make(map[int]map[string]interface{})- done, err := ParseSSEStream[map[string]interface{}](resp.Body, func(event map[string]interface{}) error {- common.Info(fmt.Sprintf("%v", event))-- tokenUsage, found, usageErr := decodeOpenAICompatibleStreamUsage(event)- if usageErr != nil {- return usageErr- }- if found {- applyStreamUsage(chatModelConfig, modelUsage, tokenUsage)- }-- choices, ok := event["choices"].([]interface{})- if !ok || len(choices) == 0 {- return nil- }-- firstChoice, ok := choices[0].(map[string]interface{})- if !ok {- return nil- }- if finishReason, ok := firstChoice["finish_reason"].(string); ok && finishReason != "" {- sawTerminal = true- }-- delta, ok := firstChoice["delta"].(map[string]interface{})- if !ok {- return nil- }-- if accumulateToolCallDeltas(delta, accumulatedToolCalls) {- return nil- }-- content, ok := delta["content"].(string)- if ok && content != "" {- if err := sender(&content, nil); err != nil {- return err- }- }-- reasoningContent, ok := delta["reasoning_content"].(string)- if ok && reasoningContent != "" {- if err := sender(nil, &reasoningContent); err != nil {- return err- }- }-- return nil+ return a.baseModel.doStreamRequest(ctx, url, apiConfig, reqBody, streamCallTimeout, func(body io.ReadCloser) error {+ return HandleStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig, sender)})- if err != nil {- return fmt.Errorf("failed to scan response body: %w", err)- }- if !done && !sawTerminal {- return fmt.Errorf("aliyun: stream ended before [DONE] or finish_reason")- }-- setSortedToolCallsResult(chatModelConfig, accumulatedToolCalls)-- // Send [DONE] marker for OpenAI compatibility- endOfStream := "[DONE]"- return sender(&endOfStream, nil)}// applyQwen3ThinkingDefault ensures enable_thinking=false is sent for qwen3diff --git a/internal/entity/models/astraflow.go b/internal/entity/models/astraflow.goindex c144ecfbb2..063a25321e 100644--- a/internal/entity/models/astraflow.go+++ b/internal/entity/models/astraflow.go@@ -88,72 +88,12 @@ func (a *AstraflowModel) ChatWithMessages(ctx context.Context, modelName string,if chatModelConfig != nil {}- jsonData, err := json.Marshal(reqBody)- if err != nil {- return nil, fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))- if err != nil {- return nil, fmt.Errorf("failed to create request: %w", err)- }-- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))-- resp, err := a.baseModel.httpClient.Do(req)- if err != nil {- return nil, fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- body, err := io.ReadAll(resp.Body)+ body, err := a.baseModel.doRequest(ctx, url, apiConfig, reqBody, nonStreamCallTimeout)if err != nil {- return nil, fmt.Errorf("failed to read response: %w", err)- }- if resp.StatusCode != http.StatusOK {- return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))- }-- var result map[string]interface{}- if err = json.Unmarshal(body, &result); err != nil {- return nil, fmt.Errorf("failed to parse response: %w", err)- }-- choices, ok := result["choices"].([]interface{})- if !ok || len(choices) == 0 {- return nil, fmt.Errorf("no choices in response")- }-- firstChoice, ok := choices[0].(map[string]interface{})- if !ok {- return nil, fmt.Errorf("invalid choice format")- }-- messageMap, ok := firstChoice["message"].(map[string]interface{})- if !ok {- return nil, fmt.Errorf("invalid message format")- }-- content, ok := messageMap["content"].(string)- toolCalls := extractToolCalls(messageMap)- if !ok && len(toolCalls) == 0 {- return nil, fmt.Errorf("invalid content format")- }-- reasonContent := ""- if r, ok := messageMap["reasoning_content"].(string); ok {- reasonContent = r+ return nil, err}- return &ChatResponse{- Answer: &content,- ReasonContent: &reasonContent,- ToolCalls: toolCalls,- }, nil+ return HandleNonStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig)}// ChatStreamlyWithSender opens the SSE chat-completions@@ -180,80 +120,13 @@ func (a *AstraflowModel) ChatStreamlyWithSender(ctx context.Context, modelName surl := fmt.Sprintf("%s/%s", baseURL, a.baseModel.URLSuffix.Chat)reqBody := buildRequestBody(chatModelConfig, modelName, messages, true)-- jsonData, err := json.Marshal(reqBody)- if err != nil {- return fmt.Errorf("failed to marshal request: %w", err)- }-- // SSE is long-lived; rely on the transport's ResponseHeaderTimeout- // to cap connection-establishment instead of a hard deadline.- req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))- if err != nil {- return fmt.Errorf("failed to create request: %w", err)- }- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))-- resp, err := a.baseModel.httpClient.Do(req)- if err != nil {- return fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- if resp.StatusCode != http.StatusOK {- body, _ := io.ReadAll(resp.Body)- return fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))+ reqBody["stream_options"] = map[string]any{+ "include_usage": true,}- sawTerminal := false- accumulatedToolCalls := make(map[int]map[string]any)- done, err := ParseSSEStream[map[string]interface{}](resp.Body, func(event map[string]interface{}) error {- if apiErr, ok := event["error"]; ok {- return fmt.Errorf("astraflow: upstream stream error: %v", apiErr)- }-- choices, ok := event["choices"].([]interface{})- if !ok || len(choices) == 0 {- return nil- }- firstChoice, ok := choices[0].(map[string]interface{})- if !ok {- return nil- }- if delta, ok := firstChoice["delta"].(map[string]interface{}); ok {- accumulateToolCallDeltas(delta, accumulatedToolCalls)- if r, ok := delta["reasoning_content"].(string); ok && r != "" {- rr := r- if err := sender(nil, &rr); err != nil {- return err- }- }- if c, ok := delta["content"].(string); ok && c != "" {- cc := c- if err := sender(&cc, nil); err != nil {- return err- }- }- }- if finish, ok := firstChoice["finish_reason"].(string); ok && finish != "" {- sawTerminal = true- }- return nil+ return a.baseModel.doStreamRequest(ctx, url, apiConfig, reqBody, streamCallTimeout, func(body io.ReadCloser) error {+ return HandleStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig, sender)})- if err != nil {- return fmt.Errorf("failed to scan response body: %w", err)- }- setSortedToolCallsResult(chatModelConfig, accumulatedToolCalls)- if !done && !sawTerminal {- return fmt.Errorf("astraflow: stream ended before [DONE] or finish_reason")- }-- endOfStream := "[DONE]"- if err := sender(&endOfStream, nil); err != nil {- return err- }- return nil}func (a *AstraflowModel) ListModels(ctx context.Context, apiConfig *APIConfig) ([]ListModelResponse, error) {diff --git a/internal/entity/models/avian.go b/internal/entity/models/avian.goindex fb67eec171..486abe5429 100644--- a/internal/entity/models/avian.go+++ b/internal/entity/models/avian.go@@ -17,7 +17,6 @@package modelsimport (- "bytes""context""encoding/json""fmt"@@ -54,33 +53,13 @@ func (a *AvianModel) Name() string {}func (a *AvianModel) chatURL(apiConfig *APIConfig) (string, error) {-baseURL, err := a.baseModel.GetBaseURL(apiConfig)if err != nil {return "", err}- baseURL = strings.TrimSuffix(baseURL, "/")return fmt.Sprintf("%s/%s", baseURL, a.baseModel.URLSuffix.Chat), nil}-type avianChatMessage struct {- Content string `json:"content"`- ReasoningContent string `json:"reasoning_content"`- Reasoning string `json:"reasoning"`-}--type avianChatChoice struct {- Message avianChatMessage `json:"message"`- Delta avianChatMessage `json:"delta"`- FinishReason string `json:"finish_reason"`-}--type avianChatResponse struct {- Choices []avianChatChoice `json:"choices"`- Error interface{} `json:"error"`- FinishReason string `json:"finish_reason"`-}-func (a *AvianModel) ChatWithMessages(ctx context.Context, modelName string, messages []Message, apiConfig *APIConfig, chatModelConfig *ChatConfig, modelUsage *common.ModelUsage) (*ChatResponse, error) {if err := a.baseModel.APIConfigCheck(apiConfig); err != nil {return nil, err@@ -97,55 +76,14 @@ func (a *AvianModel) ChatWithMessages(ctx context.Context, modelName string, mesreturn nil, err}- jsonData, err := json.Marshal(buildRequestBody(chatModelConfig, modelName, messages, false))- if err != nil {- return nil, fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)- defer cancel()+ reqBody := buildRequestBody(chatModelConfig, modelName, messages, false)- req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewBuffer(jsonData))+ body, err := a.baseModel.doRequest(ctx, url, apiConfig, reqBody, nonStreamCallTimeout)if err != nil {- return nil, fmt.Errorf("failed to create request: %w", err)- }- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))-- resp, err := a.baseModel.httpClient.Do(req)- if err != nil {- return nil, fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- body, err := io.ReadAll(resp.Body)- if err != nil {- return nil, fmt.Errorf("failed to read response: %w", err)- }- if resp.StatusCode != http.StatusOK {- return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))- }-- var result avianChatResponse- if err = json.Unmarshal(body, &result); err != nil {- return nil, fmt.Errorf("failed to parse response: %w", err)- }- if result.Error != nil {- return nil, fmt.Errorf("avian: upstream error: %v", result.Error)- }- if len(result.Choices) == 0 {- return nil, fmt.Errorf("no choices in response")+ return nil, err}- content := result.Choices[0].Message.Content- reasonContent := result.Choices[0].Message.ReasoningContent- if reasonContent == "" {- reasonContent = result.Choices[0].Message.Reasoning- }- return &ChatResponse{- Answer: &content,- ReasonContent: &reasonContent,- }, nil+ return HandleNonStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig)}func (a *AvianModel) ChatStreamlyWithSender(ctx context.Context, modelName string, messages []Message, apiConfig *APIConfig, chatModelConfig *ChatConfig, modelUsage *common.ModelUsage, sender func(*string, *string) error) error {@@ -171,79 +109,25 @@ func (a *AvianModel) ChatStreamlyWithSender(ctx context.Context, modelName strinreturn err}- jsonData, err := json.Marshal(buildRequestBody(chatModelConfig, modelName, messages, true))- if err != nil {- return fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, streamCallTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewBuffer(jsonData))- if err != nil {- return fmt.Errorf("failed to create request: %w", err)- }- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))-- resp, err := a.baseModel.httpClient.Do(req)- if err != nil {- return fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- if resp.StatusCode != http.StatusOK {- body, _ := io.ReadAll(resp.Body)- return fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))+ reqBody := buildRequestBody(chatModelConfig, modelName, messages, true)+ reqBody["stream_options"] = map[string]interface{}{+ "include_usage": true,}-- sawTerminal := false- accumulatedToolCalls := make(map[int]map[string]any)- done, err := ParseSSEStream[map[string]any](resp.Body, func(event map[string]any) error {- choices, ok := event["choices"].([]interface{})- if !ok || len(choices) == 0 {- return nil- }-- firstChoice, ok := choices[0].(map[string]interface{})- if !ok {- return nil- }-- delta, ok := firstChoice["delta"].(map[string]interface{})- if !ok {- return nil- }-- accumulateToolCallDeltas(delta, accumulatedToolCalls)-- reasoningContent, ok := delta["reasoning_content"].(string)- if ok && reasoningContent != "" {- if err = sender(nil, &reasoningContent); err != nil {- return err+ if chatModelConfig != nil && chatModelConfig.Thinking != nil {+ if *chatModelConfig.Thinking {+ reqBody["thinking"] = map[string]interface{}{+ "type": "enabled",}- }-- content, ok := delta["content"].(string)- if ok && content != "" {- if err = sender(&content, nil); err != nil {- return err+ } else {+ reqBody["thinking"] = map[string]interface{}{+ "type": "disabled",}}-- return nil- })- if err != nil {- return fmt.Errorf("failed to scan response body: %w", err)- }- if !done && !sawTerminal {- return fmt.Errorf("avian: stream ended before [DONE] or finish_reason")}- setSortedToolCallsResult(chatModelConfig, accumulatedToolCalls)-- endOfStream := "[DONE]"- return sender(&endOfStream, nil)+ return a.baseModel.doStreamRequest(ctx, url, apiConfig, reqBody, streamCallTimeout, func(body io.ReadCloser) error {+ return HandleStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig, sender)+ })}type avianModelInfo struct {diff --git a/internal/entity/models/azure_openai.go b/internal/entity/models/azure_openai.goindex 44b355e39d..cb56ac9868 100644--- a/internal/entity/models/azure_openai.go+++ b/internal/entity/models/azure_openai.go@@ -141,43 +141,7 @@ func (a *AzureOpenAIModel) ChatWithMessages(ctx context.Context, modelName strinreturn nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))}- var result map[string]interface{}- if err = json.Unmarshal(body, &result); err != nil {- return nil, fmt.Errorf("failed to parse response: %w", err)- }-- choices, ok := result["choices"].([]interface{})- if !ok || len(choices) == 0 {- return nil, fmt.Errorf("no choices in response")- }-- firstChoice, ok := choices[0].(map[string]interface{})- if !ok {- return nil, fmt.Errorf("invalid choice format")- }-- messageMap, ok := firstChoice["message"].(map[string]interface{})- if !ok {- return nil, fmt.Errorf("invalid message format")- }-- content, ok := messageMap["content"].(string)- if !ok {- return nil, fmt.Errorf("invalid content format")- }-- var reasonContent string- if rc, ok := messageMap["reasoning_content"].(string); ok {- reasonContent = rc- if reasonContent != "" && reasonContent[0] == '\n' {- reasonContent = reasonContent[1:]- }- }-- return &ChatResponse{- Answer: &content,- ReasonContent: &reasonContent,- }, nil+ return HandleNonStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig)}// ChatStreamlyWithSender sends messages and streams the response via the@@ -241,6 +205,10 @@ func (a *AzureOpenAIModel) ChatStreamlyWithSender(ctx context.Context, modelNameif err != nil {return fmt.Errorf("failed to marshal request: %w", err)}++ ctx, cancel := context.WithTimeout(ctx, streamCallTimeout)+ defer cancel()+req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))if err != nil {return fmt.Errorf("failed to create request: %w", err)@@ -260,49 +228,7 @@ func (a *AzureOpenAIModel) ChatStreamlyWithSender(ctx context.Context, modelNamereturn fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))}- sawTerminal := false- done, err := ParseSSEStream[map[string]interface{}](resp.Body, func(event map[string]interface{}) error {- choices, ok := event["choices"].([]interface{})- if !ok || len(choices) == 0 {- return nil- }-- firstChoice, ok := choices[0].(map[string]interface{})- if !ok {- return nil- }-- delta, ok := firstChoice["delta"].(map[string]interface{})- if !ok {- return nil- }-- if reasoningContent, ok := delta["reasoning_content"].(string); ok && reasoningContent != "" {- if err := sender(nil, &reasoningContent); err != nil {- return err- }- }-- if content, ok := delta["content"].(string); ok && content != "" {- if err := sender(&content, nil); err != nil {- return err- }- }-- if finishReason, ok := firstChoice["finish_reason"].(string); ok && finishReason != "" {- sawTerminal = true- }- return nil- })- if err != nil {- return fmt.Errorf("failed to scan response body: %w", err)- }- if !done && !sawTerminal {- return fmt.Errorf("azure-openai: stream ended before [DONE] or finish_reason")- }-- endOfStream := "[DONE]"- return sender(&endOfStream, nil)+ return HandleStreamingResponse(resp.Body, modelUsage, chatModelConfig, OpenAIParserConfig, sender)}type azureEmbeddingResponse struct {diff --git a/internal/entity/models/baichuan.go b/internal/entity/models/baichuan.goindex 217752d572..dc81ce9ce5 100644--- a/internal/entity/models/baichuan.go+++ b/internal/entity/models/baichuan.go@@ -49,29 +49,6 @@ func (b *BaichuanModel) Name() string {return "BaiChuan"}-type BaiChuanChatResponse struct {- ID string `json:"id"`- Choices []struct {- FinishReason string `json:"finish_reason"`- Index int `json:"index"`- Message struct {- Content string `json:"content"`- Role string `json:"role"`- ToolCalls []map[string]any `json:"tool_calls"`- } `json:"message"`- Logprobs interface{} `json:"logprobs"`- } `json:"choices"`- Created int `json:"created"`- Model string `json:"model"`- Object string `json:"object"`- Usage struct {- CompletionTokens int `json:"completion_tokens"`- PromptTokens int `json:"prompt_tokens"`- TotalTokens int `json:"total_tokens"`- SearchCount int `json:"search_count"`- } `json:"usage"`-}-func (b *BaichuanModel) ChatWithMessages(ctx context.Context, modelName string, messages []Message, apiConfig *APIConfig, chatModelConfig *ChatConfig, modelUsage *common.ModelUsage) (*ChatResponse, error) {if err := b.baseModel.APIConfigCheck(apiConfig); err != nil {return nil, err@@ -87,66 +64,12 @@ func (b *BaichuanModel) ChatWithMessages(ctx context.Context, modelName string,url := fmt.Sprintf("%s/%s", resolvedBaseURL, b.baseModel.URLSuffix.Chat)reqBody := buildRequestBody(chatModelConfig, modelName, messages, false)- jsonData, err := json.Marshal(reqBody)- if err != nil {- return nil, fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))- if err != nil {- return nil, fmt.Errorf("failed to create request: %w", err)- }-- req.Header.Add("Content-Type", "application/json")- req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))-- resp, err := b.baseModel.httpClient.Do(req)- if err != nil {- return nil, fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- body, err := io.ReadAll(resp.Body)+ body, err := b.baseModel.doRequest(ctx, url, apiConfig, reqBody, nonStreamCallTimeout)if err != nil {- return nil, fmt.Errorf("failed to read response body: %w", err)- }-- if resp.StatusCode != http.StatusOK {- return nil, fmt.Errorf("failed to send request: %d %s", resp.StatusCode, string(body))+ return nil, err}- // Parse response- return parseChatCompletionResponse(body, chatModelConfig, modelUsage, func(body []byte, chatConfig *ChatConfig) (chatResponseParts, error) {- var result BaiChuanChatResponse- if err := json.Unmarshal(body, &result); err != nil {- return chatResponseParts{}, fmt.Errorf("failed to unmarshal response: %w", err)- }- if len(result.Choices) == 0 {- return chatResponseParts{}, fmt.Errorf("no choices in response")- }-- choice := &result.Choices[0]- content := choice.Message.Content- if content == "" && len(choice.Message.ToolCalls) == 0 {- return chatResponseParts{}, fmt.Errorf("no message in response")- }-- emptyReason := ""- return chatResponseParts{- RequestID: result.ID,- Content: &content,- ReasonContent: &emptyReason,- ToolCalls: choice.Message.ToolCalls,- Usage: &TokenUsage{- PromptTokens: result.Usage.PromptTokens,- CompletionTokens: result.Usage.CompletionTokens,- TotalTokens: result.Usage.TotalTokens,- },- }, nil- })+ return HandleNonStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig)}func (b *BaichuanModel) ChatStreamlyWithSender(ctx context.Context, modelName string, messages []Message, apiConfig *APIConfig, modelConfig *ChatConfig, modelUsage *common.ModelUsage, sender func(*string, *string) error) error {@@ -165,90 +88,11 @@ func (b *BaichuanModel) ChatStreamlyWithSender(ctx context.Context, modelName sturl := fmt.Sprintf("%s/%s", resolvedBaseURL, b.baseModel.URLSuffix.Chat)reqBody := buildRequestBody(modelConfig, modelName, messages, true)+ reqBody["stream_options"] = map[string]interface{}{"include_usage": true}- jsonData, err := json.Marshal(reqBody)- if err != nil {- return fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, streamCallTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))- if err != nil {- return fmt.Errorf("failed to create request: %w", err)- }-- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))-- resp, err := b.baseModel.httpClient.Do(req)- if err != nil {- return fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- if resp.StatusCode != http.StatusOK {- body, _ := io.ReadAll(resp.Body)- return fmt.Errorf("invalid status code: %d, body: %s", resp.StatusCode, string(body))- }-- // SSE parsing: read line by line- sawTerminal := false- accumulatedToolCalls := make(map[int]map[string]any)- done, err := ParseSSEStream[map[string]interface{}](resp.Body, func(event map[string]interface{}) error {- common.Info(fmt.Sprintf("%v", event))-- tokenUsage, found, usageErr := decodeOpenAICompatibleStreamUsage(event)- if usageErr != nil {- return usageErr- }- if found {- applyStreamUsage(modelConfig, modelUsage, tokenUsage)- }-- choices, ok := event["choices"].([]interface{})- if !ok || len(choices) == 0 {- return nil- }-- firstChoice, ok := choices[0].(map[string]interface{})- if !ok {- return nil- }-- delta, ok := firstChoice["delta"].(map[string]interface{})- if !ok {- return nil- }-- accumulateToolCallDeltas(delta, accumulatedToolCalls)-- content, ok := delta["content"].(string)- if ok && content != "" {- if err := sender(&content, nil); err != nil {- return err- }- }-- finishReason, ok := firstChoice["finish_reason"].(string)- if ok && finishReason != "" {- sawTerminal = true- }- return nil+ return b.baseModel.doStreamRequest(ctx, url, apiConfig, reqBody, streamCallTimeout, func(body io.ReadCloser) error {+ return HandleStreamingResponse(body, modelUsage, modelConfig, OpenAIParserConfig, sender)})- if err != nil {- return fmt.Errorf("failed to scan response body: %w", err)- }- if !done && !sawTerminal {- return fmt.Errorf("baichuan: stream ended before [DONE] or finish_reason")- }-- setSortedToolCallsResult(modelConfig, accumulatedToolCalls)-- // Send [DONE] marker for OpenAI compatibility- endOfStream := "[DONE]"- return sender(&endOfStream, nil)}func (b *BaichuanModel) Embed(ctx context.Context, modelName *string, texts []string, apiConfig *APIConfig, embeddingConfig *EmbeddingConfig, modelUsage *common.ModelUsage) ([]EmbeddingData, error) {diff --git a/internal/entity/models/baidu.go b/internal/entity/models/baidu.goindex a6dcb178df..3b86a1f702 100644--- a/internal/entity/models/baidu.go+++ b/internal/entity/models/baidu.go@@ -50,37 +50,6 @@ func (b *BaiduModel) Name() string {return "BaiduYiyan"}-type BaiduChatResponse struct {- ID string `json:"id"`- Object string `json:"object"`- Created int64 `json:"created"`- Model string `json:"model"`- Choices []struct {- Index int `json:"index"`- Message struct {- Role string `json:"role"`- Content *string `json:"content"`- ToolCalls []map[string]any `json:"tool_calls"`- ReasoningContent *string `json:"reasoning_content"`- } `json:"message"`- FinishReason string `json:"finish_reason"`- } `json:"choices"`- Usage struct {- PromptTokens int `json:"prompt_tokens"`- PromptTokensDetails struct {- SearchTokens int `json:"search_tokens"`- CachedTokens int `json:"cached_tokens"`- } `json:"prompt_tokens_details"`- CompletionTokens int `json:"completion_tokens"`- TotalTokens int `json:"total_tokens"`- } `json:"usage"`- SearchResult struct {- Index int `json:"index"`- URL string `json:"url"`- Title string `json:"title"`- } `json:"search_result"`-}-func (b *BaiduModel) ChatWithMessages(ctx context.Context, modelName string, messages []Message, apiConfig *APIConfig, chatModelConfig *ChatConfig, modelUsage *common.ModelUsage) (*ChatResponse, error) {if err := b.baseModel.APIConfigCheck(apiConfig); err != nil {return nil, err@@ -142,82 +111,12 @@ func (b *BaiduModel) ChatWithMessages(ctx context.Context, modelName string, mes}}- jsonData, err := json.Marshal(reqBody)- if err != nil {- return nil, fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))- if err != nil {- return nil, fmt.Errorf("failed to create request: %w", err)- }-- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))-- resp, err := b.baseModel.httpClient.Do(req)- if err != nil {- return nil, fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- body, err := io.ReadAll(resp.Body)+ body, err := b.baseModel.doRequest(ctx, url, apiConfig, reqBody, nonStreamCallTimeout)if err != nil {- return nil, fmt.Errorf("failed to read response body: %w", err)- }-- if resp.StatusCode != http.StatusOK {- return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))+ return nil, err}- return parseChatCompletionResponse(body, chatModelConfig, modelUsage, func(body []byte, chatConfig *ChatConfig) (chatResponseParts, error) {- var result BaiduChatResponse- if err := json.Unmarshal(body, &result); err != nil {- return chatResponseParts{}, fmt.Errorf("failed to parse response: %w", err)- }- if len(result.Choices) == 0 {- return chatResponseParts{}, fmt.Errorf("no choices in response")- }-- choice := &result.Choices[0]- content := ""- if choice.Message.Content != nil {- content = *choice.Message.Content- }- reasonContent := ""- if chatConfig != nil && chatConfig.Thinking != nil && *chatConfig.Thinking {- if choice.Message.ReasoningContent != nil {- reasonContent = *choice.Message.ReasoningContent- }- if reasonContent != "" && reasonContent[0] == '\n' {- reasonContent = reasonContent[1:]- }- }-- totalTokens := result.Usage.TotalTokens- if totalTokens == 0 {- totalTokens = result.Usage.PromptTokens + result.Usage.CompletionTokens- }- var usage *TokenUsage- if totalTokens > 0 {- usage = &TokenUsage{- PromptTokens: result.Usage.PromptTokens,- CompletionTokens: result.Usage.CompletionTokens,- TotalTokens: totalTokens,- }- }-- return chatResponseParts{- RequestID: result.ID,- Content: &content,- ReasonContent: &reasonContent,- ToolCalls: choice.Message.ToolCalls,- Usage: usage,- }, nil- })+ return HandleNonStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig)}func (b *BaiduModel) ChatStreamlyWithSender(ctx context.Context, modelName string, messages []Message, apiConfig *APIConfig, modelConfig *ChatConfig, modelUsage *common.ModelUsage, sender func(*string, *string) error) error {@@ -237,6 +136,9 @@ func (b *BaiduModel) ChatStreamlyWithSender(ctx context.Context, modelName strin// Build request body with streaming enabledreqBody := buildRequestBody(modelConfig, modelName, messages, true)+ reqBody["stream_options"] = map[string]interface{}{+ "include_usage": true,+ }if modelConfig != nil && modelConfig.Thinking != nil {lowerModelName := strings.ToLower(modelName)@@ -278,101 +180,9 @@ func (b *BaiduModel) ChatStreamlyWithSender(ctx context.Context, modelName strin}}- jsonData, err := json.Marshal(reqBody)- if err != nil {- return fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, streamCallTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))- if err != nil {- return fmt.Errorf("failed to create request: %w", err)- }-- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))-- resp, err := b.baseModel.httpClient.Do(req)- if err != nil {- return fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- if resp.StatusCode != http.StatusOK {- body, _ := io.ReadAll(resp.Body)- return fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))- }-- // SSE parsing: read line by line- sawTerminal := false- accumulatedToolCalls := make(map[int]map[string]interface{})- done, err := ParseSSEStream[map[string]interface{}](resp.Body, func(event map[string]interface{}) error {- common.Info(fmt.Sprintf("%v", event))-- tokenUsage, found, usageErr := decodeOpenAICompatibleStreamUsage(event)- if usageErr != nil {- return usageErr- }- if found {- applyStreamUsage(modelConfig, modelUsage, tokenUsage)- }-- choices, ok := event["choices"].([]interface{})- if !ok || len(choices) == 0 {- return nil- }-- firstChoice, ok := choices[0].(map[string]interface{})- if !ok {- return nil- }-- delta, ok := firstChoice["delta"].(map[string]interface{})- if !ok {- return nil- }-- accumulateToolCallDeltas(delta, accumulatedToolCalls)-- reasoningContent, ok := delta["reasoning_content"].(string)- if ok && reasoningContent != "" {- if err = sender(nil, &reasoningContent); err != nil {- return err- }- }-- content, ok := delta["content"].(string)- if ok && content != "" {- if err = sender(&content, nil); err != nil {- return err- }- }-- finishReason, ok := firstChoice["finish_reason"].(string)- if ok && finishReason != "" {- sawTerminal = true- }-- return nil+ return b.baseModel.doStreamRequest(ctx, url, apiConfig, reqBody, streamCallTimeout, func(body io.ReadCloser) error {+ return HandleStreamingResponse(body, modelUsage, modelConfig, OpenAIParserConfig, sender)})- if err != nil {- return fmt.Errorf("failed to scan response body: %w", err)- }- if !done && !sawTerminal {- return fmt.Errorf("baidu: stream ended before [DONE] or finish_reason")- }-- setSortedToolCallsResult(modelConfig, accumulatedToolCalls)-- // Send [DONE] marker for OpenAI compatibility- endOfStream := "[DONE]"- if err = sender(&endOfStream, nil); err != nil {- return err- }-- return nil}type baiduEmbeddingResponse struct {diff --git a/internal/entity/models/base_model.go b/internal/entity/models/base_model.goindex 0cd4b888a4..107d388ec8 100644--- a/internal/entity/models/base_model.go+++ b/internal/entity/models/base_model.go@@ -214,6 +214,7 @@ func (b *BaseModel) doStreamRequest(ctx context.Context, url string, apiConfig *if err != nil {return err}+ req.Header.Set("Accept", "text/event-stream")resp, err := b.httpClient.Do(req)if err != nil {diff --git a/internal/entity/models/cometapi.go b/internal/entity/models/cometapi.goindex 2c2b9a5a83..610b1e6e31 100644--- a/internal/entity/models/cometapi.go+++ b/internal/entity/models/cometapi.go@@ -94,114 +94,11 @@ func (c *CometAPIModel) balanceURL(apiKey string) string {return parsed.String()}-func newCometAPIJSONRequest(ctx context.Context, method string, endpoint string, payload interface{}, apiKey string) (*http.Request, error) {- jsonData, err := json.Marshal(payload)- if err != nil {- return nil, fmt.Errorf("failed to marshal request: %w", err)- }-- req, err := http.NewRequestWithContext(ctx, method, endpoint, bytes.NewBuffer(jsonData))- if err != nil {- return nil, fmt.Errorf("failed to create request: %w", err)- }- req.Header.Set("Content-Type", "application/json")- if apiKey != "" {- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", apiKey))- }- return req, nil-}--type cometapiHTTPResponse struct {- StatusCode int- Status string- Body []byte-}--func (c *CometAPIModel) doCometAPIRequest(req *http.Request) (*cometapiHTTPResponse, error) {- resp, err := c.baseModel.httpClient.Do(req)- if err != nil {- return nil, fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- body, err := io.ReadAll(resp.Body)- if err != nil {- return nil, fmt.Errorf("failed to read response: %w", err)- }-- return &cometapiHTTPResponse{- StatusCode: resp.StatusCode,- Status: resp.Status,- Body: body,- }, nil-}--type cometapiChatResponsePayload struct {- Choices []cometapiChatChoice `json:"choices"`-}--type cometapiChatChoice struct {- Message cometapiChatMessage `json:"message"`- Delta cometapiChatDelta `json:"delta"`- FinishReason string `json:"finish_reason"`-}--type cometapiChatMessage struct {- Content *string `json:"content"`- ReasoningContent string `json:"reasoning_content"`-}--type cometapiChatDelta struct {- Content string `json:"content"`- ReasoningContent string `json:"reasoning_content"`-}--func parseCometAPIChatResponse(body []byte) (*ChatResponse, error) {- var parsed cometapiChatResponsePayload- if err := json.Unmarshal(body, &parsed); err != nil {- return nil, fmt.Errorf("failed to parse response: %w", err)- }- if len(parsed.Choices) == 0 {- return nil, fmt.Errorf("no choices in response")- }- if parsed.Choices[0].Message.Content == nil {- return nil, fmt.Errorf("invalid content format")- }-- content := *parsed.Choices[0].Message.Content- reasonContent := strings.TrimLeft(parsed.Choices[0].Message.ReasoningContent, "\n")- return &ChatResponse{- Answer: &content,- ReasonContent: &reasonContent,- }, nil-}--func parseCometAPIStreamEvent(data string) (content string, reasonContent string, terminal bool, ok bool) {- var event cometapiChatResponsePayload- if err := json.Unmarshal([]byte(data), &event); err != nil {- return "", "", false, false- }- if len(event.Choices) == 0 {- return "", "", false, false- }- choice := event.Choices[0]- return choice.Delta.Content, choice.Delta.ReasoningContent, choice.FinishReason != "", true-}--type cometapiModelCatalogResponse struct {- Data []cometapiModelCatalogItem `json:"data"`-}--type cometapiModelCatalogItem struct {- ID string `json:"id"`-}-// ChatWithMessages sends multiple messages with roles and returns the response.func (c *CometAPIModel) ChatWithMessages(ctx context.Context, modelName string, messages []Message, apiConfig *APIConfig, chatModelConfig *ChatConfig, modelUsage *common.ModelUsage) (*ChatResponse, error) {if err := c.baseModel.APIConfigCheck(apiConfig); err != nil {return nil, err}- apiKey := *apiConfig.ApiKeyif err := validateCometAPIModelName(modelName); err != nil {return nil, err}@@ -217,22 +114,20 @@ func (c *CometAPIModel) ChatWithMessages(ctx context.Context, modelName string,reqBody := buildRequestBody(chatModelConfig, modelName, messages, false)- ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)- defer cancel()-- req, err := newCometAPIJSONRequest(ctx, "POST", url, reqBody, apiKey)- if err != nil {- return nil, err+ if chatModelConfig != nil && chatModelConfig.Thinking != nil {+ if *chatModelConfig.Thinking {+ reqBody["thinking"] = map[string]interface{}{"type": "enabled"}+ } else {+ reqBody["thinking"] = map[string]interface{}{"type": "disabled"}+ }}- resp, err := c.doCometAPIRequest(req)++ body, err := c.baseModel.doRequest(ctx, url, apiConfig, reqBody, nonStreamCallTimeout)if err != nil {return nil, err}- if resp.StatusCode != http.StatusOK {- return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(resp.Body))- }- return parseCometAPIChatResponse(resp.Body)+ return HandleNonStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig)}// ChatStreamlyWithSender sends messages and streams the response@@ -253,8 +148,6 @@ func (c *CometAPIModel) ChatStreamlyWithSender(ctx context.Context, modelName streturn fmt.Errorf("messages is empty")}- apiKey := *apiConfig.ApiKey-url, err := c.endpointURL(cometapiRegion(apiConfig), c.baseModel.URLSuffix.Chat)if err != nil {return err@@ -271,76 +164,20 @@ func (c *CometAPIModel) ChatStreamlyWithSender(ctx context.Context, modelName st}reqBody := buildRequestBody(chatModelConfig, modelName, messages, true)- req, err := newCometAPIJSONRequest(ctx, "POST", url, reqBody, apiKey)- if err != nil {- return err- }- resp, err := c.baseModel.httpClient.Do(req)- if err != nil {- return fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- if resp.StatusCode != http.StatusOK {- body, _ := io.ReadAll(resp.Body)- return fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))- }-- sawTerminal := false- accumulatedToolCalls := make(map[int]map[string]any)- done, err := ParseSSEStream[map[string]interface{}](resp.Body, func(event map[string]interface{}) error {- choices, ok := event["choices"].([]interface{})- if !ok || len(choices) == 0 {- return nil- }-- firstChoice, ok := choices[0].(map[string]interface{})- if !ok {- return nil- }-- delta, ok := firstChoice["delta"].(map[string]interface{})- if !ok {- return nil- }-- accumulateToolCallDeltas(delta, accumulatedToolCalls)-- reasoningContent, ok := delta["reasoning_content"].(string)- if ok && reasoningContent != "" {- if err = sender(nil, &reasoningContent); err != nil {- return err- }- }-- content, ok := delta["content"].(string)- if ok && content != "" {- if err = sender(&content, nil); err != nil {- return err+ if chatModelConfig != nil {+ if chatModelConfig.Thinking != nil {+ if *chatModelConfig.Thinking {+ reqBody["thinking"] = map[string]interface{}{"type": "enabled"}+ } else {+ reqBody["thinking"] = map[string]interface{}{"type": "disabled"}}}-- if finishReason, ok := firstChoice["finish_reason"].(string); ok && finishReason != "" {- sawTerminal = true- }-- return nil- })- if err != nil {- return fmt.Errorf("failed to scan response body: %w", err)- }- if !done && !sawTerminal {- return fmt.Errorf("cometapi: stream ended before [DONE] or finish_reason")- }-- setSortedToolCallsResult(chatModelConfig, accumulatedToolCalls)-- endOfStream := "[DONE]"- if err := sender(&endOfStream, nil); err != nil {- return err}+ reqBody["stream_options"] = map[string]interface{}{"include_usage": true}- return nil+ return c.baseModel.doStreamRequest(ctx, url, apiConfig, reqBody, streamCallTimeout, func(body io.ReadCloser) error {+ return HandleStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig, sender)+ })}type cometapiEmbeddingData struct {@@ -355,12 +192,6 @@ type cometapiEmbeddingResponse struct {Object string `json:"object"`}-type cometapiEmbeddingRequest struct {- Model string `json:"model"`- Input []string `json:"input"`- Dimensions int `json:"dimensions,omitempty"`-}-// Embed turns a list of texts into embedding vectorsfunc (c *CometAPIModel) Embed(ctx context.Context, modelName *string, texts []string, apiConfig *APIConfig, embeddingConfig *EmbeddingConfig, modelUsage *common.ModelUsage) ([]EmbeddingData, error) {if err := c.baseModel.APIConfigCheck(apiConfig); err != nil {@@ -371,8 +202,6 @@ func (c *CometAPIModel) Embed(ctx context.Context, modelName *string, texts []streturn []EmbeddingData{}, nil}- apiKey := *apiConfig.ApiKey-if modelName == nil || strings.TrimSpace(*modelName) == "" {return nil, fmt.Errorf("model name is required")}@@ -382,33 +211,21 @@ func (c *CometAPIModel) Embed(ctx context.Context, modelName *string, texts []streturn nil, err}- reqBody := cometapiEmbeddingRequest{- Model: *modelName,- Input: texts,+ reqBody := map[string]any{+ "model": *modelName,+ "input": texts,}if embeddingConfig != nil && embeddingConfig.Dimension > 0 {- reqBody.Dimensions = embeddingConfig.Dimension- }-- ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)- defer cancel()-- req, err := newCometAPIJSONRequest(ctx, "POST", url, reqBody, apiKey)- if err != nil {- return nil, err+ reqBody["dimensions"] = embeddingConfig.Dimension}- resp, err := c.doCometAPIRequest(req)+ body, err := c.baseModel.doRequest(ctx, url, apiConfig, reqBody, nonStreamCallTimeout)if err != nil {return nil, err}- if resp.StatusCode != http.StatusOK {- return nil, fmt.Errorf("CometAPI embeddings API error: %s, body: %s", resp.Status, string(resp.Body))- }-var parsed cometapiEmbeddingResponse- if err = json.Unmarshal(resp.Body, &parsed); err != nil {+ if err = json.Unmarshal(body, &parsed); err != nil {return nil, fmt.Errorf("failed to parse response: %w", err)}@@ -450,19 +267,28 @@ func (c *CometAPIModel) ListModels(ctx context.Context, apiConfig *APIConfig) ([if err != nil {return nil, fmt.Errorf("failed to create request: %w", err)}+ if apiConfig != nil && apiConfig.ApiKey != nil {+ req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))+ }- resp, err := c.doCometAPIRequest(req)+ resp, err := c.baseModel.httpClient.Do(req)if err != nil {- return nil, err+ return nil, fmt.Errorf("failed to send request: %w", err)+ }+ defer resp.Body.Close()++ body, err := io.ReadAll(resp.Body)+ if err != nil {+ return nil, fmt.Errorf("failed to read response: %w", err)}if resp.StatusCode != http.StatusOK {- return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(resp.Body))+ return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))}// Parse responsevar modelList ModelList- if err = json.Unmarshal(resp.Body, &modelList); err != nil {+ if err = json.Unmarshal(body, &modelList); err != nil {return nil, fmt.Errorf("failed to parse response: %w", err)}return ParseListModel(modelList), nil@@ -485,17 +311,23 @@ func (c *CometAPIModel) Balance(ctx context.Context, apiConfig *APIConfig) (map[return nil, fmt.Errorf("failed to create request: %w", err)}- resp, err := c.doCometAPIRequest(req)+ resp, err := c.baseModel.httpClient.Do(req)+ if err != nil {+ return nil, fmt.Errorf("failed to send request: %w", err)+ }+ defer resp.Body.Close()++ body, err := io.ReadAll(resp.Body)if err != nil {- return nil, err+ return nil, fmt.Errorf("failed to read response: %w", err)}if resp.StatusCode != http.StatusOK {- return nil, fmt.Errorf("CometAPI quota API error: %s, body: %s", resp.Status, string(resp.Body))+ return nil, fmt.Errorf("CometAPI quota API error: %s, body: %s", resp.Status, string(body))}var result map[string]interface{}- if err = json.Unmarshal(resp.Body, &result); err != nil {+ if err = json.Unmarshal(body, &result); err != nil {return nil, fmt.Errorf("failed to parse response: %w", err)}diff --git a/internal/entity/models/cometapi_test.go b/internal/entity/models/cometapi_test.goindex 7403a28dfd..694c82efba 100644--- a/internal/entity/models/cometapi_test.go+++ b/internal/entity/models/cometapi_test.go@@ -801,7 +801,7 @@ func TestCometAPIEmbedRejectsHTTPError(t *testing.T) {apiKey := "test-key"model := "text-embedding-3-small"_, err := m.Embed(ctx, &model, []string{"a"}, &APIConfig{ApiKey: &apiKey}, nil, nil)- if err == nil || !strings.Contains(err.Error(), "CometAPI embeddings API error") {- t.Errorf("expected CometAPI embeddings API error, got %v", err)+ if err == nil || !strings.Contains(err.Error(), "status 401") {+ t.Errorf("expected embeddings API error for HTTP 401, got %v", err)}}diff --git a/internal/entity/models/deepinfra.go b/internal/entity/models/deepinfra.goindex 4f3889cd2d..cbaee44386 100644--- a/internal/entity/models/deepinfra.go+++ b/internal/entity/models/deepinfra.go@@ -88,73 +88,12 @@ func (d *DeepInfraModel) ChatWithMessages(ctx context.Context, modelName string,}}- jsonData, err := json.Marshal(reqBody)- if err != nil {- return nil, fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))- if err != nil {- return nil, fmt.Errorf("failed to create request: %w", err)- }-- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))-- resp, err := d.baseModel.httpClient.Do(req)- if err != nil {- return nil, fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- body, err := io.ReadAll(resp.Body)+ body, err := d.baseModel.doRequest(ctx, url, apiConfig, reqBody, nonStreamCallTimeout)if err != nil {- return nil, fmt.Errorf("failed to read response body: %w", err)- }-- // Parse result- var result map[string]interface{}- if err := json.Unmarshal(body, &result); err != nil {- return nil, fmt.Errorf("failed to unmarshal response body: %w", err)- }-- choices, ok := result["choices"].([]interface{})- if !ok || len(choices) == 0 {- return nil, fmt.Errorf("no choices in response")- }-- firstChoice, ok := choices[0].(map[string]interface{})- if !ok {- return nil, fmt.Errorf("invalid choice format")- }-- messageMap, ok := firstChoice["message"].(map[string]interface{})- if !ok {- return nil, fmt.Errorf("invalid message format")- }-- content, ok := messageMap["content"].(string)- toolCalls := extractToolCalls(messageMap)- if !ok && len(toolCalls) == 0 {- return nil, fmt.Errorf("invalid content format")- }-- var reasonContent string- if rc, ok := messageMap["reasoning_content"].(string); ok {- reasonContent = rc- }-- chatResponse := &ChatResponse{- Answer: &content,- }- if reasonContent != "" {- chatResponse.ReasonContent = &reasonContent+ return nil, err}- return chatResponse, nil+ return HandleNonStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig)}func (d *DeepInfraModel) ChatStreamlyWithSender(ctx context.Context, modelName string, messages []Message, apiConfig *APIConfig, modelConfig *ChatConfig, modelUsage *common.ModelUsage, sender func(*string, *string) error) error {@@ -189,86 +128,11 @@ func (d *DeepInfraModel) ChatStreamlyWithSender(ctx context.Context, modelName s}}- jsonData, err := json.Marshal(reqBody)- if err != nil {- return fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, streamCallTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))- if err != nil {- return fmt.Errorf("failed to create request: %w", err)- }-- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))+ reqBody["stream_options"] = map[string]any{"include_usage": true}- resp, err := d.baseModel.httpClient.Do(req)- if err != nil {- return fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- if resp.StatusCode != http.StatusOK {- body, _ := io.ReadAll(resp.Body)- return fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, string(body))- }-- sawTerminal := false- accumulatedToolCalls := make(map[int]map[string]any)- done, err := ParseSSEStream[map[string]interface{}](resp.Body, func(event map[string]interface{}) error {- common.Info(fmt.Sprintf("%v", event))-- choices, ok := event["choices"].([]interface{})- if !ok || len(choices) == 0 {- return nil- }-- firstChoice, ok := choices[0].(map[string]interface{})- if !ok {- return nil- }-- delta, ok := firstChoice["delta"].(map[string]interface{})- if !ok {- return nil- }-- accumulateToolCallDeltas(delta, accumulatedToolCalls)-- reasoningContent, ok := delta["reasoning_content"].(string)- if ok && reasoningContent != "" {- if err := sender(nil, &reasoningContent); err != nil {- return err- }- }-- content, ok := delta["content"].(string)- if ok && content != "" {- if err := sender(&content, nil); err != nil {- return err- }- }-- finishReason, ok := firstChoice["finish_reason"].(string)- if ok && finishReason != "" {- sawTerminal = true- }- return nil+ return d.baseModel.doStreamRequest(ctx, url, apiConfig, reqBody, streamCallTimeout, func(body io.ReadCloser) error {+ return HandleStreamingResponse(body, modelUsage, modelConfig, OpenAIParserConfig, sender)})- if err != nil {- return fmt.Errorf("failed to scan response body: %w", err)- }- setSortedToolCallsResult(modelConfig, accumulatedToolCalls)- if !done && !sawTerminal {- return fmt.Errorf("deepinfra: stream ended before [DONE] or finish_reason")- }-- // Send [DONE] marker for OpenAI compatibility- endOfStream := "[DONE]"- return sender(&endOfStream, nil)}func (d *DeepInfraModel) Embed(ctx context.Context, modelName *string, texts []string, apiConfig *APIConfig, embeddingConfig *EmbeddingConfig, modelUsage *common.ModelUsage) ([]EmbeddingData, error) {diff --git a/internal/entity/models/futurmix.go b/internal/entity/models/futurmix.goindex cb81d8c4dd..5e22ad738b 100644--- a/internal/entity/models/futurmix.go+++ b/internal/entity/models/futurmix.go@@ -17,12 +17,9 @@package modelsimport (- "bytes""context"- "encoding/json""fmt""io"- "net/http""ragflow/internal/common""strings")@@ -60,54 +57,6 @@ func (f *FuturMixModel) endpointURL(region, suffix string) (string, error) {return fmt.Sprintf("%s/%s", baseURL, strings.TrimLeft(suffix, "/")), nil}-func futurmixRegion(apiConfig *APIConfig) string {- if apiConfig != nil && apiConfig.Region != nil && *apiConfig.Region != "" {- return *apiConfig.Region- }- return "default"-}--func newFuturMixJSONRequest(ctx context.Context, method, endpoint string, payload interface{}, apiKey string) (*http.Request, error) {- var body io.Reader- if payload != nil {- jsonData, err := json.Marshal(payload)- if err != nil {- return nil, fmt.Errorf("failed to marshal request: %w", err)- }- body = bytes.NewBuffer(jsonData)- }-- req, err := http.NewRequestWithContext(ctx, method, endpoint, body)- if err != nil {- return nil, fmt.Errorf("failed to create request: %w", err)- }- req.Header.Set("Content-Type", "application/json")- if apiKey != "" {- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", apiKey))- }- return req, nil-}--type futurmixChatChoice struct {- Message futurmixChatMessage `json:"message"`- Delta futurmixChatDelta `json:"delta"`- FinishReason string `json:"finish_reason"`-}--type futurmixChatMessage struct {- Content *string `json:"content"`- ReasoningContent string `json:"reasoning_content"`-}--type futurmixChatDelta struct {- Content string `json:"content"`- ReasoningContent string `json:"reasoning_content"`-}--type futurmixChatResponse struct {- Choices []futurmixChatChoice `json:"choices"`-}-// ChatWithMessages sends a non-streaming chat completionfunc (f *FuturMixModel) ChatWithMessages(ctx context.Context, modelName string, messages []Message, apiConfig *APIConfig, chatModelConfig *ChatConfig, modelUsage *common.ModelUsage) (*ChatResponse, error) {if err := f.baseModel.APIConfigCheck(apiConfig); err != nil {@@ -125,55 +74,24 @@ func (f *FuturMixModel) ChatWithMessages(ctx context.Context, modelName string,url := fmt.Sprintf("%s/%s", resolvedBaseURL, f.baseModel.URLSuffix.Chat)reqBody := buildRequestBody(chatModelConfig, modelName, messages, false)-- jsonData, err := json.Marshal(reqBody)- if err != nil {- return nil, fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))- if err != nil {- return nil, fmt.Errorf("failed to create request: %w", err)- }-- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))-- resp, err := f.baseModel.httpClient.Do(req)- if err != nil {- return nil, fmt.Errorf("failed to send request: %w", err)+ if chatModelConfig != nil && chatModelConfig.Thinking != nil {+ if *chatModelConfig.Thinking {+ reqBody["thinking"] = map[string]any{+ "type": "enabled",+ }+ } else {+ reqBody["thinking"] = map[string]any{+ "type": "disabled",+ }+ }}- defer resp.Body.Close()- body, err := io.ReadAll(resp.Body)+ body, err := f.baseModel.doRequest(ctx, url, apiConfig, reqBody, nonStreamCallTimeout)if err != nil {- return nil, fmt.Errorf("failed to read response: %w", err)- }-- if resp.StatusCode != http.StatusOK {- return nil, fmt.Errorf("futurmix chat API error: %s, body: %s", resp.Status, string(body))- }-- var parsed futurmixChatResponse- if err := json.Unmarshal(body, &parsed); err != nil {- return nil, fmt.Errorf("failed to parse response: %w", err)- }- if len(parsed.Choices) == 0 {- return nil, fmt.Errorf("no choices in response")- }- if parsed.Choices[0].Message.Content == nil {- return nil, fmt.Errorf("invalid content format")+ return nil, err}- content := *parsed.Choices[0].Message.Content- reasonContent := parsed.Choices[0].Message.ReasoningContent- return &ChatResponse{- Answer: &content,- ReasonContent: &reasonContent,- }, nil+ return HandleNonStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig)}// ChatStreamlyWithSender sends a streaming chat completion@@ -192,77 +110,25 @@ func (f *FuturMixModel) ChatStreamlyWithSender(ctx context.Context, modelName st}url := fmt.Sprintf("%s/%s", resolvedBaseURL, f.baseModel.URLSuffix.Chat)- reqBody := buildRequestBody(chatModelConfig, modelName, messages, false)-- jsonData, err := json.Marshal(reqBody)- if err != nil {- return fmt.Errorf("failed to marshal request: %w", err)- }-- ctx, cancel := context.WithTimeout(ctx, nonStreamCallTimeout)- defer cancel()-- req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))- if err != nil {- return fmt.Errorf("failed to create request: %w", err)- }-- req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiConfig.ApiKey))-- resp, err := f.baseModel.httpClient.Do(req)- if err != nil {- return fmt.Errorf("failed to send request: %w", err)- }- defer resp.Body.Close()-- if resp.StatusCode != http.StatusOK {- body, _ := io.ReadAll(resp.Body)- return fmt.Errorf("futurmix chat stream API error: %s, body: %s", resp.Status, string(body))+ reqBody := buildRequestBody(chatModelConfig, modelName, messages, true)+ reqBody["stream_options"] = map[string]any{+ "include_usage": true,}-- accumulatedToolCalls := make(map[int]map[string]any)- if _, err = ParseSSEStream[map[string]interface{}](resp.Body, func(event map[string]interface{}) error {- choices, ok := event["choices"].([]interface{})- if !ok || len(choices) == 0 {- return nil- }-- firstChoice, ok := choices[0].(map[string]interface{})- if !ok {- return nil- }-- delta, ok := firstChoice["delta"].(map[string]interface{})- if !ok {- return nil- }-- accumulateToolCallDeltas(delta, accumulatedToolCalls)-- reasoningContent, ok := delta["reasoning_content"].(string)- if ok && reasoningContent != "" {- if err = sender(nil, &reasoningContent); err != nil {- return err+ if chatModelConfig != nil && chatModelConfig.Thinking != nil {+ if *chatModelConfig.Thinking {+ reqBody["thinking"] = map[string]any{+ "type": "enabled",}- }-- content, ok := delta["content"].(string)- if ok && content != "" {- if err = sender(&content, nil); err != nil {- return err+ } else {+ reqBody["thinking"] = map[string]any{+ "type": "disabled",}}-- return nil- }); err != nil {- return fmt.Errorf("failed to scan response body: %w", err)}- setSortedToolCallsResult(chatModelConfig, accumulatedToolCalls)-- endOfStream := "[DONE]"- return sender(&endOfStream, nil)+ return f.baseModel.doStreamRequest(ctx, url, apiConfig, reqBody, streamCallTimeout, func(body io.ReadCloser) error {+ return HandleStreamingResponse(body, modelUsage, chatModelConfig, OpenAIParserConfig, sender)+ })}// Embed is not exposed by the FuturMix API per the public docs.diff --git a/internal/entity/models/response_handler.go b/internal/entity/models/response_handler.goindex f21e93aa83..d52d01a70a 100644--- a/internal/entity/models/response_handler.go+++ b/internal/entity/models/response_handler.go@@ -191,12 +191,17 @@ func extractContentAndChoices(result map[string]any) (*string, *string, []map[st}var reasonContent *string- if rc, ok := messageMap["reasoning_content"].(string); ok {+ if rc, ok := messageMap["reasoning_content"].(string); ok && rc != "" {reason := rc- if reason != "" && reason[0] == '\n' {+ if reason[0] == '\n' {reason = reason[1:]}reasonContent = &reason+ } else if rc, ok := messageMap["reasoning"].(string); ok && rc != "" {+ // Some providers (e.g. Avian) report reasoning under a top-level+ // "reasoning" field instead of "reasoning_content".+ reason := rc+ reasonContent = &reason} else {// Always return a non-nil pointer so callers can rely on it.empty := ""