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
Dev: add LLM_DEBUG to debug LLM request and response. (#19703)
Wang Qi2132d5d8fbe0
diff --git a/docker/.env b/docker/.envindex 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=xxxdiff --git a/internal/common/environments.go b/internal/common/environments.goindex 9740817bbb..cc526ae10c 100644--- a/internal/common/environments.go+++ b/internal/common/environments.go@@ -19,6 +19,7 @@ package commonimport ("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 variablesconst (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.goindex 3d7e99ef11..d18729f55e 100644--- a/internal/common/logger.go+++ b/internal/common/logger.go@@ -17,7 +17,9 @@package commonimport (+ "bytes""fmt"+ "io""log""os""path/filepath"@@ -65,8 +67,49 @@ const (defaultMaxSizeMB = 100defaultMaxBackups = 10defaultMaxAgeDays = 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 {returndiff --git a/internal/common/logger_test.go b/internal/common/logger_test.gonew file mode 100644index 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.goindex 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]stringURLSuffix 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-inferencediff --git a/internal/entity/models/builtin.go b/internal/entity/models/builtin.goindex 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.goindex 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 stringdiff --git a/internal/entity/models/google.go b/internal/entity/models/google.goindex 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 {