Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

Dev: add LLM_DEBUG to debug LLM request and response. (#19703)

Wang Qi2132d5d8fbe0
diff --git a/docker/.env b/docker/.env
index a933326bfd..5997e07846 100644
--- a/docker/.env
+++ b/docker/.env
@@ -328,6 +328,10 @@ RERANK_TOKEN_LIMIT_MODE=${RERANK_TOKEN_LIMIT_MODE:-truncate}
# For example, the following line changes the log level of `ragflow.es_conn` to `DEBUG`:
# LOG_LEVELS=ragflow.es_conn=DEBUG
+# Enable debug logging for the LLM provider, it will log the request and response of the LLM provider.
+# This may contain sensitive information and generate massive logs. Use with caution.
+# LLM_DEBUG=true
+
# aliyun OSS configuration
# STORAGE_IMPL=OSS
# ACCESS_KEY=xxx
diff --git a/internal/common/environments.go b/internal/common/environments.go
index 9740817bbb..cc526ae10c 100644
--- a/internal/common/environments.go
+++ b/internal/common/environments.go
@@ -19,6 +19,7 @@ package common
import (
"os"
"path/filepath"
+ "strconv"
"strings"
)
@@ -30,6 +31,11 @@ func GetEnvSmall(key string) string {
return strings.ToLower(GetEnv(key))
}
+func IsLLMDebugEnabled() bool {
+ enabled, err := strconv.ParseBool(strings.TrimSpace(GetEnv(EnvLLMDebug)))
+ return err == nil && enabled
+}
+
// environment variables
const (
EnvTensorrtDLAServer = "TENSORRT_DLA_SVR"
@@ -99,6 +105,7 @@ const (
EnvOpenAIAPIKey = "OPENAI_API_KEY"
EnvOpenAIBaseURL = "OPENAI_BASE_URL"
EnvOpenAIModel = "OPENAI_MODEL"
+ EnvLLMDebug = "LLM_DEBUG"
EnvStageHandExtractSchemaJSON = "STAGEHAND_EXTRACT_SCHEMA_JSON"
EnvSandboxProviderType = "SANDBOX_PROVIDER_TYPE"
EnvSandboxExecutorManagerURL = "SANDBOX_EXECUTOR_MANAGER_URL"
diff --git a/internal/common/logger.go b/internal/common/logger.go
index 3d7e99ef11..d18729f55e 100644
--- a/internal/common/logger.go
+++ b/internal/common/logger.go
@@ -17,7 +17,9 @@
package common
import (
+ "bytes"
"fmt"
+ "io"
"log"
"os"
"path/filepath"
@@ -65,8 +67,49 @@ const (
defaultMaxSizeMB = 100
defaultMaxBackups = 10
defaultMaxAgeDays = 30
+ cyanLogMarker = "[[RAGFLOW_CYAN_LOG]]"
+ greenLogMarker = "[[RAGFLOW_GREEN_LOG]]"
+ redLogMarker = "[[RAGFLOW_RED_LOG]]"
+ resetLogMarker = "[[RAGFLOW_RESET_LOG]]"
+ ansiBrightCyan = "\x1b[96m"
+ ansiGreen = "\x1b[32m"
+ ansiRed = "\x1b[31m"
+ ansiReset = "\x1b[0m"
)
+type coloredLineWriteSyncer struct {
+ zapcore.WriteSyncer
+ color bool
+}
+
+func (s coloredLineWriteSyncer) Write(p []byte) (int, error) {
+ if !bytes.Contains(p, []byte(cyanLogMarker)) && !bytes.Contains(p, []byte(greenLogMarker)) && !bytes.Contains(p, []byte(redLogMarker)) {
+ return s.WriteSyncer.Write(p)
+ }
+
+ line := bytes.Clone(p)
+ if s.color {
+ line = bytes.ReplaceAll(line, []byte(cyanLogMarker), []byte(ansiBrightCyan))
+ line = bytes.ReplaceAll(line, []byte(greenLogMarker), []byte(ansiGreen))
+ line = bytes.ReplaceAll(line, []byte(redLogMarker), []byte(ansiRed))
+ line = bytes.ReplaceAll(line, []byte(resetLogMarker), []byte(ansiReset))
+ } else {
+ line = bytes.ReplaceAll(line, []byte(cyanLogMarker), nil)
+ line = bytes.ReplaceAll(line, []byte(greenLogMarker), nil)
+ line = bytes.ReplaceAll(line, []byte(redLogMarker), nil)
+ line = bytes.ReplaceAll(line, []byte(resetLogMarker), nil)
+ }
+
+ n, err := s.WriteSyncer.Write(line)
+ if err != nil {
+ return 0, err
+ }
+ if n != len(line) {
+ return 0, io.ErrShortWrite
+ }
+ return len(p), nil
+}
+
func parseZapLevel(level string) (zapcore.Level, error) {
switch strings.ToLower(strings.TrimSpace(level)) {
case "debug":
@@ -144,7 +187,6 @@ func InitLogger(level string, file FileOutput, serviceName string) error {
maxAge = defaultMaxAgeDays
}
- syncers := []zapcore.WriteSyncer{zapcore.AddSync(os.Stdout)}
ljLogger := &lumberjack.Logger{
Filename: filepath.Join(file.Path, file.Filename),
MaxSize: maxSize,
@@ -153,13 +195,29 @@ func InitLogger(level string, file FileOutput, serviceName string) error {
Compress: file.Compress,
LocalTime: true,
}
- syncers = append(syncers, zapcore.AddSync(ljLogger))
-
- core := zapcore.NewCore(
- zapcore.NewConsoleEncoder(encoderConfig),
- zap.CombineWriteSyncers(syncers...),
- atomicLevel,
- )
+ stdoutSyncer := zapcore.AddSync(os.Stdout)
+ fileSyncer := zapcore.AddSync(ljLogger)
+ var core zapcore.Core
+ if IsLLMDebugEnabled() {
+ core = zapcore.NewTee(
+ zapcore.NewCore(
+ zapcore.NewConsoleEncoder(encoderConfig),
+ coloredLineWriteSyncer{WriteSyncer: stdoutSyncer, color: true},
+ atomicLevel,
+ ),
+ zapcore.NewCore(
+ zapcore.NewConsoleEncoder(encoderConfig),
+ coloredLineWriteSyncer{WriteSyncer: fileSyncer},
+ atomicLevel,
+ ),
+ )
+ } else {
+ core = zapcore.NewCore(
+ zapcore.NewConsoleEncoder(encoderConfig),
+ zap.CombineWriteSyncers(stdoutSyncer, fileSyncer),
+ atomicLevel,
+ )
+ }
if serviceName != "" {
Logger = zap.New(core,
@@ -198,6 +256,20 @@ func Info(msg string, fields ...zap.Field) {
Logger.Info(msg, fields...)
}
+// LogRequestResponseInfo writes the request portion in bright cyan. The
+// response portion is green for success and red for failure on stdout. File
+// output remains uncolored.
+func LogRequestResponseInfo(request, response string, responseSucceeded bool) {
+ if Logger == nil {
+ return
+ }
+ responseMarker := redLogMarker
+ if responseSucceeded {
+ responseMarker = greenLogMarker
+ }
+ Logger.Info(cyanLogMarker + request + responseMarker + " " + response + resetLogMarker)
+}
+
func Error(msg string, err error, fields ...zap.Field) {
if Logger == nil {
return
diff --git a/internal/common/logger_test.go b/internal/common/logger_test.go
new file mode 100644
index 0000000000..bf42ec37b4
--- /dev/null
+++ b/internal/common/logger_test.go
@@ -0,0 +1,92 @@
+//
+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package common
+
+import (
+ "bytes"
+ "testing"
+
+ "go.uber.org/zap"
+ "go.uber.org/zap/zapcore"
+)
+
+func TestColoredLineWriteSyncerColorsRequestAndResponse(t *testing.T) {
+ var output bytes.Buffer
+ syncer := coloredLineWriteSyncer{WriteSyncer: zapcore.AddSync(&output), color: true}
+ input := []byte("timestamp\tinfo\t" + cyanLogMarker + `url=https://provider.example payload={"query":"hello"}` + greenLogMarker + ` response_code=200 response_body={"answer":"ok"}` + resetLogMarker + "\n")
+
+ n, err := syncer.Write(input)
+ if err != nil {
+ t.Fatalf("Write() error = %v", err)
+ }
+ if n != len(input) {
+ t.Fatalf("Write() bytes = %d, want %d", n, len(input))
+ }
+ want := "timestamp\tinfo\t" + ansiBrightCyan + `url=https://provider.example payload={"query":"hello"}` + ansiGreen + ` response_code=200 response_body={"answer":"ok"}` + ansiReset + "\n"
+ if got := output.String(); got != want {
+ t.Errorf("colored line = %q, want %q", got, want)
+ }
+}
+
+func TestColoredLineWriteSyncerKeepsFileLinePlain(t *testing.T) {
+ var output bytes.Buffer
+ syncer := coloredLineWriteSyncer{WriteSyncer: zapcore.AddSync(&output)}
+ input := []byte("timestamp\tinfo\t" + cyanLogMarker + `url=https://provider.example payload={"query":"hello"}` + greenLogMarker + ` response_code=200 response_body={"answer":"ok"}` + resetLogMarker + "\n")
+
+ if _, err := syncer.Write(input); err != nil {
+ t.Fatalf("Write() error = %v", err)
+ }
+ want := "timestamp\tinfo\t" + `url=https://provider.example payload={"query":"hello"} response_code=200 response_body={"answer":"ok"}` + "\n"
+ if got := output.String(); got != want {
+ t.Errorf("file line = %q, want %q", got, want)
+ }
+}
+
+func TestLogRequestResponseInfoColorsResponseByOutcome(t *testing.T) {
+ tests := []struct {
+ name string
+ response string
+ responseSucceeded bool
+ responseColor string
+ }{
+ {name: "success", response: `response_code=200 response_body={"answer":"ok"}`, responseSucceeded: true, responseColor: ansiGreen},
+ {name: "failure", response: `response_code=503 response_body={"error":"unavailable"}`, responseColor: ansiRed},
+ }
+
+ for _, test := range tests {
+ t.Run(test.name, func(t *testing.T) {
+ var output bytes.Buffer
+ core := zapcore.NewCore(
+ zapcore.NewConsoleEncoder(zapcore.EncoderConfig{
+ MessageKey: "msg",
+ LineEnding: zapcore.DefaultLineEnding,
+ }),
+ coloredLineWriteSyncer{WriteSyncer: zapcore.AddSync(&output), color: true},
+ zapcore.InfoLevel,
+ )
+ previousLogger := Logger
+ Logger = zap.New(core)
+ LogRequestResponseInfo(`url=https://provider.example payload={"query":"hello"}`, test.response, test.responseSucceeded)
+ Logger = previousLogger
+
+ want := ansiBrightCyan + `url=https://provider.example payload={"query":"hello"}` + test.responseColor + " " + test.response + ansiReset + "\n"
+ if got := output.String(); got != want {
+ t.Errorf("encoded line = %q, want %q", got, want)
+ }
+ })
+ }
+}
diff --git a/internal/entity/models/base_model.go b/internal/entity/models/base_model.go
index 992da05fe1..eb6dd71524 100644
--- a/internal/entity/models/base_model.go
+++ b/internal/entity/models/base_model.go
@@ -24,14 +24,20 @@ import (
"fmt"
"io"
"net/http"
+ "net/url"
"ragflow/internal/common"
"ragflow/internal/engine/clickhouse"
"ragflow/internal/utility"
"sort"
"strings"
+ "sync"
"time"
)
+const (
+ redactedLogValue = "[REDACTED]"
+)
+
type BaseModel struct {
BaseURL map[string]string
URLSuffix URLSuffix
@@ -445,7 +451,9 @@ func ParseListModel(modelList ModelList) []ListModelResponse {
}
// NewDriverHTTPClient returns an *http.Client with the standard connection-pool
-// settings and an SSRF guard wired into its Transport.
+// settings, an SSRF guard, and opt-in provider request/response logging wired
+// into its Transport. Logging is disabled unless LLM_DEBUG is true when the
+// client is created, normally during process startup.
//
// allowPrivate selects the guard strictness:
// - false (cloud-hosted drivers): every request is validated with
@@ -475,9 +483,189 @@ func NewDriverHTTPClient(allowPrivate bool) *http.Client {
} else {
rt = &strictSSRFTransport{base: rt}
}
+ rt = newProviderLoggingTransport(rt)
return &http.Client{Transport: rt}
}
+func newProviderLoggingTransport(base http.RoundTripper) http.RoundTripper {
+ if base == nil {
+ base = http.DefaultTransport
+ }
+ if !common.IsLLMDebugEnabled() {
+ return base
+ }
+ return &providerLoggingTransport{base: base}
+}
+
+type providerLoggingTransport struct {
+ base http.RoundTripper
+}
+
+func (t *providerLoggingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+ payload, err := readAndRestoreRequestBody(req)
+ if err != nil {
+ return nil, err
+ }
+ providerURL := redactProviderURL(req.URL)
+ logPayload := redactProviderBody(payload)
+
+ resp, err := t.base.RoundTrip(req)
+ if err != nil {
+ logProviderCall(providerURL, logPayload, 0, "", err)
+ return nil, err
+ }
+ if resp.Body == nil {
+ logProviderCall(providerURL, logPayload, resp.StatusCode, "", nil)
+ return resp, nil
+ }
+
+ resp.Body = &providerResponseBody{
+ ReadCloser: resp.Body,
+ log: func(body []byte) {
+ logProviderCall(providerURL, logPayload, resp.StatusCode, redactProviderBody(body), nil)
+ },
+ }
+ return resp, nil
+}
+
+// providerResponseBody captures bytes while callers consume them, preserving
+// streaming delivery instead of eagerly reading the entire provider response.
+type providerResponseBody struct {
+ io.ReadCloser
+ body bytes.Buffer
+ once sync.Once
+ log func([]byte)
+}
+
+func (b *providerResponseBody) Read(p []byte) (int, error) {
+ n, err := b.ReadCloser.Read(p)
+ if n > 0 {
+ _, _ = b.body.Write(p[:n])
+ }
+ if err == io.EOF {
+ b.logOnce()
+ }
+ return n, err
+}
+
+func (b *providerResponseBody) Close() error {
+ err := b.ReadCloser.Close()
+ b.logOnce()
+ return err
+}
+
+func (b *providerResponseBody) logOnce() {
+ b.once.Do(func() {
+ b.log(b.body.Bytes())
+ })
+}
+
+func readAndRestoreRequestBody(req *http.Request) ([]byte, error) {
+ if req.Body == nil {
+ return nil, nil
+ }
+ body, err := io.ReadAll(req.Body)
+ if err != nil {
+ return nil, fmt.Errorf("failed to read provider request body for logging: %w", err)
+ }
+ _ = req.Body.Close()
+ req.Body = io.NopCloser(bytes.NewReader(body))
+ req.ContentLength = int64(len(body))
+ return body, nil
+}
+
+func redactProviderURL(requestURL *url.URL) string {
+ if requestURL == nil {
+ return ""
+ }
+ redacted := *requestURL
+ if redacted.User != nil {
+ redacted.User = url.User(redacted.User.Username())
+ }
+ query := redacted.Query()
+ for key := range query {
+ if isSensitiveLogKey(key) {
+ query.Set(key, redactedLogValue)
+ }
+ }
+ redacted.RawQuery = query.Encode()
+ return redacted.String()
+}
+
+func redactProviderBody(body []byte) string {
+ if len(body) == 0 {
+ return ""
+ }
+
+ var value any
+ if err := json.Unmarshal(body, &value); err == nil {
+ redactProviderValue(value)
+ if redacted, err := json.Marshal(value); err == nil {
+ return string(redacted)
+ }
+ }
+
+ lines := strings.Split(string(body), "\n")
+ redactedAny := false
+ for i, line := range lines {
+ prefix, data, ok := strings.Cut(line, "data:")
+ if !ok || strings.TrimSpace(data) == "[DONE]" {
+ continue
+ }
+ var event any
+ if err := json.Unmarshal([]byte(strings.TrimSpace(data)), &event); err != nil {
+ continue
+ }
+ redactProviderValue(event)
+ redacted, err := json.Marshal(event)
+ if err != nil {
+ continue
+ }
+ lines[i] = prefix + "data: " + string(redacted)
+ redactedAny = true
+ }
+ if redactedAny {
+ return strings.Join(lines, "\n")
+ }
+ return string(body)
+}
+
+func redactProviderValue(value any) {
+ switch value := value.(type) {
+ case map[string]any:
+ for key, child := range value {
+ if isSensitiveLogKey(key) {
+ value[key] = redactedLogValue
+ continue
+ }
+ redactProviderValue(child)
+ }
+ case []any:
+ for _, child := range value {
+ redactProviderValue(child)
+ }
+ }
+}
+
+func isSensitiveLogKey(key string) bool {
+ normalized := strings.NewReplacer("-", "", "_", "", ".", "").Replace(strings.ToLower(key))
+ switch normalized {
+ case "apikey", "authorization", "accesstoken", "refreshtoken", "password", "secret", "token", "key":
+ return true
+ default:
+ return false
+ }
+}
+
+func logProviderCall(providerURL, payload string, statusCode int, responseBody string, err error) {
+ request := fmt.Sprintf("url=%s payload=%s", providerURL, payload)
+ response := fmt.Sprintf("response_code=%d response_body=%s", statusCode, responseBody)
+ if err != nil {
+ response += " error=" + err.Error()
+ }
+ common.LogRequestResponseInfo(request, response, err == nil && statusCode >= 200 && statusCode < 300)
+}
+
// schemeSafeTransport wraps an http.RoundTripper so every outgoing request is
// validated by the lenient SSRF guard (http/https scheme + non-empty host).
// Private and loopback hosts are permitted. Used only by local-inference
diff --git a/internal/entity/models/builtin.go b/internal/entity/models/builtin.go
index b198e553d5..e49b90a04c 100644
--- a/internal/entity/models/builtin.go
+++ b/internal/entity/models/builtin.go
@@ -17,10 +17,10 @@ import (
// would otherwise block goroutines indefinitely.
var builtinHTTPClient = &http.Client{
Timeout: 30 * time.Second,
- Transport: &http.Transport{
+ Transport: newProviderLoggingTransport(&http.Transport{
MaxIdleConnsPerHost: 10,
ResponseHeaderTimeout: 10 * time.Second,
- },
+ }),
}
// BuiltinModel implements ModelDriver for Builtin (local embedding models via TEI)
diff --git a/internal/entity/models/common_test.go b/internal/entity/models/common_test.go
index 9c500e8392..5dedb238d7 100644
--- a/internal/entity/models/common_test.go
+++ b/internal/entity/models/common_test.go
@@ -6,10 +6,149 @@ import (
"io"
"net/http"
"net/http/httptest"
+ "ragflow/internal/common"
+ "strings"
"testing"
"time"
+
+ "go.uber.org/zap"
+ "go.uber.org/zap/zapcore"
+ "go.uber.org/zap/zaptest/observer"
)
+func TestDriverHTTPClientLogsProviderRequestAndResponseWhenEnabled(t *testing.T) {
+ t.Setenv(common.EnvLLMDebug, "true")
+ core, logs := observer.New(zapcore.InfoLevel)
+ previousLogger := common.Logger
+ common.Logger = zap.New(core)
+ t.Cleanup(func() {
+ common.Logger = previousLogger
+ })
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/v1/rerank" {
+ t.Fatalf("path = %q, want /v1/rerank", r.URL.Path)
+ }
+ fmt.Fprint(w, `{"answer":"ok","access_token":"response-secret"}`)
+ }))
+ defer server.Close()
+
+ client := NewDriverHTTPClient(true)
+ req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, server.URL+"/v1/rerank?key=request-secret", strings.NewReader(`{"query":"hello","api_key":"payload-secret"}`))
+ if err != nil {
+ t.Fatalf("NewRequestWithContext() error = %v", err)
+ }
+ resp, err := client.Do(req)
+ if err != nil {
+ t.Fatalf("Do() error = %v", err)
+ }
+ if _, err = io.ReadAll(resp.Body); err != nil {
+ t.Fatalf("ReadAll() error = %v", err)
+ }
+ if err = resp.Body.Close(); err != nil {
+ t.Fatalf("Close() error = %v", err)
+ }
+
+ entries := logs.All()
+ if len(entries) != 1 {
+ t.Fatalf("provider log count = %d, want 1", len(entries))
+ }
+ message := entries[0].Message
+ if strings.Contains(message, `\"`) {
+ t.Errorf("provider log contains escaped JSON: %q", message)
+ }
+ if !strings.Contains(message, `payload={"api_key":"[REDACTED]","query":"hello"}`) {
+ t.Errorf("provider log payload is not raw redacted JSON: %q", message)
+ }
+ if !strings.Contains(message, `response_code=200 response_body={"access_token":"[REDACTED]","answer":"ok"}`) {
+ t.Errorf("provider log response is not raw redacted JSON: %q", message)
+ }
+ if strings.Contains(message, "request-secret") || strings.Contains(message, "payload-secret") || strings.Contains(message, "response-secret") {
+ t.Errorf("provider log contains an unredacted secret: %q", message)
+ }
+}
+
+func TestProviderLoggingDisabledAvoidsPayloadWork(t *testing.T) {
+ t.Setenv(common.EnvLLMDebug, "")
+ core, logs := observer.New(zapcore.InfoLevel)
+ previousLogger := common.Logger
+ common.Logger = zap.New(core)
+ t.Cleanup(func() {
+ common.Logger = previousLogger
+ })
+
+ payload := &trackingReadCloser{reader: strings.NewReader(`{"query":"hello"}`)}
+ client := &http.Client{Transport: newProviderLoggingTransport(roundTripFunc(func(req *http.Request) (*http.Response, error) {
+ return &http.Response{
+ StatusCode: http.StatusNoContent,
+ Header: make(http.Header),
+ Body: http.NoBody,
+ Request: req,
+ }, nil
+ }))}
+ req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "https://provider.example/v1/rerank", payload)
+ if err != nil {
+ t.Fatalf("NewRequestWithContext() error = %v", err)
+ }
+ resp, err := client.Do(req)
+ if err != nil {
+ t.Fatalf("Do() error = %v", err)
+ }
+ if resp.Body != http.NoBody {
+ t.Fatalf("response body was wrapped while LLM_DEBUG is disabled")
+ }
+ _ = resp.Body.Close()
+
+ if payload.reads != 0 {
+ t.Fatalf("request body reads = %d, want 0 while LLM_DEBUG is disabled", payload.reads)
+ }
+ if count := logs.Len(); count != 0 {
+ t.Fatalf("provider log count = %d, want 0", count)
+ }
+}
+
+func TestIsLLMDebugEnabled(t *testing.T) {
+ tests := []struct {
+ value string
+ want bool
+ }{
+ {value: ""},
+ {value: "false"},
+ {value: "1", want: true},
+ {value: "true", want: true},
+ {value: " TRUE ", want: true},
+ }
+
+ for _, test := range tests {
+ t.Run(test.value, func(t *testing.T) {
+ t.Setenv(common.EnvLLMDebug, test.value)
+ if got := common.IsLLMDebugEnabled(); got != test.want {
+ t.Errorf("IsLLMDebugEnabled() = %v, want %v", got, test.want)
+ }
+ })
+ }
+}
+
+type roundTripFunc func(*http.Request) (*http.Response, error)
+
+func (f roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
+ return f(req)
+}
+
+type trackingReadCloser struct {
+ reader io.Reader
+ reads int
+}
+
+func (r *trackingReadCloser) Read(p []byte) (int, error) {
+ r.reads++
+ return r.reader.Read(p)
+}
+
+func (r *trackingReadCloser) Close() error {
+ return nil
+}
+
func TestBaseModelDoRequestAuthorizationHeader(t *testing.T) {
tests := []struct {
name string
diff --git a/internal/entity/models/google.go b/internal/entity/models/google.go
index f4b68c6912..b13195400c 100644
--- a/internal/entity/models/google.go
+++ b/internal/entity/models/google.go
@@ -21,6 +21,7 @@ import (
"encoding/json"
"fmt"
"math"
+ "net/http"
"ragflow/internal/common"
"ragflow/internal/entity"
"strings"
@@ -150,8 +151,9 @@ type GoogleModel struct {
func NewGoogleModel(baseURL map[string]string, urlSuffix URLSuffix) *GoogleModel {
return &GoogleModel{
baseModel: BaseModel{
- BaseURL: baseURL,
- URLSuffix: urlSuffix,
+ BaseURL: baseURL,
+ URLSuffix: urlSuffix,
+ httpClient: &http.Client{Transport: newProviderLoggingTransport(http.DefaultTransport)},
},
}
}
@@ -165,7 +167,12 @@ func (g *GoogleModel) Name() string {
}
func (g *GoogleModel) clientConfig(apiKey string, apiConfig *APIConfig) *genai.ClientConfig {
- return &genai.ClientConfig{APIKey: apiKey, Backend: genai.BackendGeminiAPI, HTTPOptions: genai.HTTPOptions{BaseURL: g.baseURL(apiConfig)}}
+ return &genai.ClientConfig{
+ APIKey: apiKey,
+ Backend: genai.BackendGeminiAPI,
+ HTTPClient: g.baseModel.httpClient,
+ HTTPOptions: genai.HTTPOptions{BaseURL: g.baseURL(apiConfig)},
+ }
}
func (g *GoogleModel) baseURL(apiConfig *APIConfig) string {