Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.
Go agentagenticaichatbotdsh-pluginembeddingsevaluationgenerative-aigolangknowledge-basellmmulti-tenantollamaopenaiquestion-answeringragrerankingsemantic-searchvector-searchwiki
feat(web-search): add Bocha AI Search provider (#3036)
Fei.Chen15727591a7c7
diff --git a/docs/docs.go b/docs/docs.goindex 73a4592a2..f27b92b65 100644--- a/docs/docs.go+++ b/docs/docs.go@@ -22622,7 +22622,8 @@ const docTemplate = `{"keenable","zhipu","exa",- "metaso"+ "metaso",+ "bocha"],"x-enum-varnames": ["WebSearchProviderTypeBing",@@ -22635,7 +22636,8 @@ const docTemplate = `{"WebSearchProviderTypeKeenable","WebSearchProviderTypeZhipu","WebSearchProviderTypeExa",- "WebSearchProviderTypeMetaso"+ "WebSearchProviderTypeMetaso",+ "WebSearchProviderTypeBocha"]},"github_com_Tencent_WeKnora_internal_types.WikiConfig": {diff --git a/docs/swagger.json b/docs/swagger.jsonindex 4ce7bff11..e22e76c35 100644--- a/docs/swagger.json+++ b/docs/swagger.json@@ -22615,7 +22615,8 @@"keenable","zhipu","exa",- "metaso"+ "metaso",+ "bocha"],"x-enum-varnames": ["WebSearchProviderTypeBing",@@ -22628,7 +22629,8 @@"WebSearchProviderTypeKeenable","WebSearchProviderTypeZhipu","WebSearchProviderTypeExa",- "WebSearchProviderTypeMetaso"+ "WebSearchProviderTypeMetaso",+ "WebSearchProviderTypeBocha"]},"github_com_Tencent_WeKnora_internal_types.WikiConfig": {diff --git a/docs/swagger.yaml b/docs/swagger.yamlindex 572ac1933..768f122df 100644--- a/docs/swagger.yaml+++ b/docs/swagger.yaml@@ -4397,6 +4397,7 @@ definitions:- zhipu- exa- metaso+ - bochatype: stringx-enum-varnames:- WebSearchProviderTypeBing@@ -4410,6 +4411,7 @@ definitions:- WebSearchProviderTypeZhipu- WebSearchProviderTypeExa- WebSearchProviderTypeMetaso+ - WebSearchProviderTypeBochagithub_com_Tencent_WeKnora_internal_types.WikiConfig:properties:content_instructions:diff --git a/frontend/src/api/web-search-provider.ts b/frontend/src/api/web-search-provider.tsindex 03cd0690c..bf43d00b4 100644--- a/frontend/src/api/web-search-provider.ts+++ b/frontend/src/api/web-search-provider.ts@@ -5,7 +5,7 @@ export interface WebSearchProviderEntity {id?: stringtenant_id?: numbername: string- provider: 'bing' | 'google' | 'duckduckgo' | 'tavily' | 'ollama' | 'baidu' | 'searxng' | 'keenable' | 'zhipu' | 'metaso' | 'exa'+ provider: 'bing' | 'google' | 'duckduckgo' | 'tavily' | 'ollama' | 'baidu' | 'searxng' | 'keenable' | 'zhipu' | 'metaso' | 'exa' | 'bocha'description?: stringparameters: {// api_key is never returned by the server in this shape; it lives behinddiff --git a/internal/application/service/web_search_provider.go b/internal/application/service/web_search_provider.goindex cb472f4dd..27bab1795 100644--- a/internal/application/service/web_search_provider.go+++ b/internal/application/service/web_search_provider.go@@ -139,7 +139,8 @@ func isValidProviderType(provider types.WebSearchProviderType) bool {types.WebSearchProviderTypeKeenable,types.WebSearchProviderTypeMetaso,types.WebSearchProviderTypeZhipu,- types.WebSearchProviderTypeExa:+ types.WebSearchProviderTypeExa,+ types.WebSearchProviderTypeBocha:return truedefault:return false@@ -184,6 +185,10 @@ func validateProviderParameters(provider types.WebSearchProviderType, params typif err := infra_web_search.ValidateMetasoParameters(params); err != nil {return err}+ case types.WebSearchProviderTypeBocha:+ if err := infra_web_search.ValidateBochaParameters(params); err != nil {+ return err+ }case types.WebSearchProviderTypeDuckDuckGo:// No API key requiredcase types.WebSearchProviderTypeKeenable:diff --git a/internal/application/service/web_search_provider_test.go b/internal/application/service/web_search_provider_test.goindex 14b3b8fe2..ef29042a3 100644--- a/internal/application/service/web_search_provider_test.go+++ b/internal/application/service/web_search_provider_test.go@@ -62,3 +62,24 @@ func TestValidateProviderParametersMetaso(t *testing.T) {t.Fatal("Metaso provider type is not accepted")}}++func TestValidateProviderParametersBocha(t *testing.T) {+ valid := types.WebSearchProviderParameters{+ APIKey: "sk-test",+ ExtraConfig: map[string]string{"freshness": "oneWeek", "summary": "true"},+ }+ if err := validateProviderParameters(types.WebSearchProviderTypeBocha, valid); err != nil {+ t.Fatalf("valid Bocha parameters rejected: %v", err)+ }+ invalid := valid+ invalid.ExtraConfig = map[string]string{"freshness": "oneHour"}+ if err := validateProviderParameters(types.WebSearchProviderTypeBocha, invalid); err == nil {+ t.Fatal("invalid Bocha freshness was accepted")+ }+ if err := validateProviderParameters(types.WebSearchProviderTypeBocha, types.WebSearchProviderParameters{}); err == nil {+ t.Fatal("missing Bocha API key was accepted")+ }+ if !isValidProviderType(types.WebSearchProviderTypeBocha) {+ t.Fatal("Bocha provider type is not accepted")+ }+}diff --git a/internal/container/container.go b/internal/container/container.goindex af4163d3c..b22fbbcee 100644--- a/internal/container/container.go+++ b/internal/container/container.go@@ -1627,6 +1627,7 @@ func registerWebSearchProviders(registry *infra_web_search.Registry) {registry.Register("zhipu", infra_web_search.NewZhipuProvider)registry.Register("exa", infra_web_search.NewExaProvider)registry.Register("metaso", infra_web_search.NewMetasoProvider)+ registry.Register("bocha", infra_web_search.NewBochaProvider)}// registerIMService registers adapter factories, loads enabled channels, anddiff --git a/internal/infrastructure/web_search/bocha.go b/internal/infrastructure/web_search/bocha.gonew file mode 100644index 000000000..143429922--- /dev/null+++ b/internal/infrastructure/web_search/bocha.go@@ -0,0 +1,253 @@+package web_search++import (+ "bytes"+ "context"+ "encoding/json"+ "fmt"+ "io"+ "net/http"+ "strconv"+ "strings"+ "time"++ "github.com/Tencent/WeKnora/internal/logger"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+)++const (+ // defaultBochaSearchURL is the hardcoded Bocha API URL.+ // Not configurable by tenants — prevents SSRF.+ defaultBochaSearchURL = "https://api.bochaai.com/v1/web-search"+ defaultBochaTimeout = 30 * time.Second+ defaultBochaResults = 10+ maxBochaResults = 50+ maxBochaResponseBytes = 4 << 20+ defaultBochaFreshness = "noLimit"+)++var validBochaFreshness = map[string]struct{}{+ "noLimit": {}, "oneDay": {}, "oneWeek": {}, "oneMonth": {}, "oneYear": {},+}++// BochaProvider implements web search using the Bocha AI Search API.+type BochaProvider struct {+ client *http.Client+ baseURL string+ apiKey string+ freshness string+ summary bool+}++func NewBochaProvider(params types.WebSearchProviderParameters) (interfaces.WebSearchProvider, error) {+ if err := ValidateBochaParameters(params); err != nil {+ return nil, err+ }+ client, err := NewSearchHTTPClient(defaultBochaTimeout, params.ProxyURL)+ if err != nil {+ return nil, err+ }+ return &BochaProvider{+ client: client, baseURL: defaultBochaSearchURL,+ apiKey: strings.TrimSpace(params.APIKey),+ freshness: bochaFreshness(params.ExtraConfig), summary: bochaSummary(params.ExtraConfig),+ }, nil+}++func ValidateBochaParameters(params types.WebSearchProviderParameters) error {+ if strings.TrimSpace(params.APIKey) == "" {+ return fmt.Errorf("API key is required for Bocha provider")+ }+ if freshness := bochaFreshness(params.ExtraConfig); freshness == "" {+ return fmt.Errorf("invalid Bocha freshness: %s", params.ExtraConfig["freshness"])+ }+ return nil+}++func bochaFreshness(extraConfig map[string]string) string {+ if freshness := strings.TrimSpace(extraConfig["freshness"]); freshness != "" {+ if _, ok := validBochaFreshness[freshness]; ok {+ return freshness+ }+ return ""+ }+ return defaultBochaFreshness+}++func bochaSummary(extraConfig map[string]string) bool {+ return strings.TrimSpace(extraConfig["summary"]) != "false"+}++func (p *BochaProvider) Name() string { return "bocha" }++func (p *BochaProvider) Search(ctx context.Context, query string, maxResults int, includeDate bool) ([]*types.WebSearchResult, error) {+ query = strings.TrimSpace(query)+ if query == "" {+ return nil, fmt.Errorf("query is empty")+ }+ if maxResults <= 0 {+ maxResults = defaultBochaResults+ }+ if maxResults > maxBochaResults {+ maxResults = maxBochaResults+ }++ body, err := json.Marshal(bochaSearchRequest{+ Query: query, Freshness: p.freshness, Summary: p.summary, Count: maxResults,+ })+ if err != nil {+ return nil, fmt.Errorf("failed to marshal Bocha request: %w", err)+ }+ req, err := http.NewRequestWithContext(ctx, http.MethodPost, p.baseURL, bytes.NewReader(body))+ if err != nil {+ return nil, fmt.Errorf("failed to create Bocha request: %w", err)+ }+ req.Header.Set("Authorization", "Bearer "+p.apiKey)+ req.Header.Set("Accept", "application/json")+ req.Header.Set("Content-Type", "application/json")++ logger.Infof(ctx, "[WebSearch][Bocha] query=%q maxResults=%d freshness=%s", query, maxResults, p.freshness)+ resp, err := p.client.Do(req)+ if err != nil {+ return nil, fmt.Errorf("failed to execute Bocha request: %w", err)+ }+ defer resp.Body.Close()+ respBody, err := readBochaResponseBody(resp.Body)+ if err != nil {+ return nil, err+ }+ if resp.StatusCode != http.StatusOK {+ return nil, bochaHTTPError(resp.StatusCode, respBody)+ }++ var response bochaSearchResponse+ if err := json.Unmarshal(respBody, &response); err != nil {+ return nil, fmt.Errorf("failed to unmarshal Bocha response: %w", err)+ }+ if response.Code != 0 && response.Code != bochaCode(http.StatusOK) {+ return nil, fmt.Errorf("Bocha API returned code %d", response.Code)+ }+ results := make([]*types.WebSearchResult, 0, len(response.Data.WebPages.Value))+ for _, item := range response.Data.WebPages.Value {+ if strings.TrimSpace(item.Name) == "" && strings.TrimSpace(item.URL) == "" {+ continue+ }+ snippet := strings.TrimSpace(item.Summary)+ if snippet == "" {+ snippet = strings.TrimSpace(item.Snippet)+ }+ result := &types.WebSearchResult{Title: item.Name, URL: item.URL, Snippet: snippet, Source: "bocha"}+ if includeDate {+ if publishedAt, ok := parseBochaDate(item.DatePublished); ok {+ result.PublishedAt = &publishedAt+ } else if publishedAt, ok := parseBochaLastCrawled(item.DateLastCrawled); ok {+ result.PublishedAt = &publishedAt+ }+ }+ results = append(results, result)+ if len(results) >= maxResults {+ break+ }+ }+ logger.Infof(ctx, "[WebSearch][Bocha] returned %d results", len(results))+ return results, nil+}++func readBochaResponseBody(reader io.Reader) ([]byte, error) {+ body, err := io.ReadAll(io.LimitReader(reader, maxBochaResponseBytes+1))+ if err != nil {+ return nil, fmt.Errorf("failed to read Bocha response: %w", err)+ }+ if len(body) > maxBochaResponseBytes {+ return nil, fmt.Errorf("Bocha response exceeds %d bytes", maxBochaResponseBytes)+ }+ return body, nil+}++func bochaHTTPError(statusCode int, body []byte) error {+ var apiError struct {+ Message string `json:"message"`+ Msg string `json:"msg"`+ }+ if json.Unmarshal(body, &apiError) == nil {+ detail := strings.TrimSpace(apiError.Message)+ if detail == "" {+ detail = strings.TrimSpace(apiError.Msg)+ }+ if detail != "" {+ return fmt.Errorf("Bocha API returned status %d: %s", statusCode, detail)+ }+ }+ detail := strings.TrimSpace(string(body))+ if len(detail) > 4096 {+ detail = detail[:4096]+ }+ if detail == "" {+ return fmt.Errorf("Bocha API returned status %d", statusCode)+ }+ return fmt.Errorf("Bocha API returned status %d: %s", statusCode, detail)+}++func parseBochaLastCrawled(value string) (time.Time, bool) {+ // Bocha v1's legacy dateLastCrawled field labels UTC+8 wall time with Z.+ // Correct only this field; datePublished and explicit offsets are accurate.+ value = strings.TrimSpace(value)+ if strings.HasSuffix(value, "Z") {+ value = strings.TrimSuffix(value, "Z") + "+08:00"+ }+ return parseBochaDate(value)+}++func parseBochaDate(value string) (time.Time, bool) {+ for _, layout := range []string{time.RFC3339Nano, "2006-01-02 15:04:05", "2006-01-02"} {+ if parsed, err := time.Parse(layout, strings.TrimSpace(value)); err == nil {+ return parsed, true+ }+ }+ return time.Time{}, false+}++// bochaCode tolerates the API's mixed code encoding: errors return a+// JSON string ("401") while success responses may return a number (200).+type bochaCode int++func (c *bochaCode) UnmarshalJSON(data []byte) error {+ s := strings.Trim(strings.TrimSpace(string(data)), `"`)+ if s == "" || s == "null" {+ *c = 0+ return nil+ }+ n, err := strconv.Atoi(s)+ if err != nil {+ *c = 0+ return nil+ }+ *c = bochaCode(n)+ return nil+}++type bochaSearchRequest struct {+ Query string `json:"query"`+ Freshness string `json:"freshness"`+ Summary bool `json:"summary"`+ Count int `json:"count"`+}++type bochaSearchResponse struct {+ Code bochaCode `json:"code"`+ Data struct {+ WebPages struct {+ Value []bochaWebPage `json:"value"`+ } `json:"webPages"`+ } `json:"data"`+}++type bochaWebPage struct {+ Name string `json:"name"`+ URL string `json:"url"`+ Snippet string `json:"snippet"`+ Summary string `json:"summary"`+ DatePublished string `json:"datePublished"`+ DateLastCrawled string `json:"dateLastCrawled"`+}diff --git a/internal/infrastructure/web_search/bocha_test.go b/internal/infrastructure/web_search/bocha_test.gonew file mode 100644index 000000000..df562f53e--- /dev/null+++ b/internal/infrastructure/web_search/bocha_test.go@@ -0,0 +1,168 @@+package web_search++import (+ "context"+ "encoding/json"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"+ "time"++ "github.com/Tencent/WeKnora/internal/types"+)++func TestBochaProviderSearch(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if r.Method != http.MethodPost {+ t.Fatalf("method = %s, want POST", r.Method)+ }+ if got := r.Header.Get("Authorization"); got != "Bearer sk-test" {+ t.Fatalf("Authorization = %q", got)+ }+ var request bochaSearchRequest+ if err := json.NewDecoder(r.Body).Decode(&request); err != nil {+ t.Fatal(err)+ }+ if request.Query != "WeKnora" || request.Freshness != "oneWeek" || !request.Summary || request.Count != 2 {+ t.Fatalf("unexpected request: %+v", request)+ }+ w.Header().Set("Content-Type", "application/json")+ _, _ = w.Write([]byte(`{"code":200,"log_id":"x","msg":null,"data":{"webPages":{"value":[+ {"name":"First","url":"https://example.com/1","summary":"Summary","snippet":"Snippet","dateLastCrawled":"2026-08-09T08:18:30Z"},+ {"name":"Second","url":"https://example.com/2","snippet":"Fallback snippet","dateLastCrawled":"invalid"},+ {"name":"Third","url":"https://example.com/3","snippet":"must be capped"}+ ]}}}`))+ }))+ defer server.Close()++ bocha := &BochaProvider{client: server.Client(), baseURL: server.URL, apiKey: "sk-test", freshness: "oneWeek", summary: true}+ results, err := bocha.Search(context.Background(), " WeKnora ", 2, true)+ if err != nil {+ t.Fatal(err)+ }+ if len(results) != 2 {+ t.Fatalf("len(results) = %d, want 2", len(results))+ }+ if results[0].Snippet != "Summary" || results[1].Snippet != "Fallback snippet" {+ t.Fatalf("unexpected snippets: %q, %q", results[0].Snippet, results[1].Snippet)+ }+ if results[0].Source != "bocha" || results[0].PublishedAt == nil {+ t.Fatalf("unexpected first result: %+v", results[0])+ }+ if want := time.Date(2026, 8, 9, 0, 18, 30, 0, time.UTC); !results[0].PublishedAt.Equal(want) {+ t.Fatalf("date = %v, want %v", results[0].PublishedAt, want)+ }+ if results[1].PublishedAt != nil {+ t.Fatalf("invalid date should be ignored: %v", results[1].PublishedAt)+ }+}++func TestBochaProviderSearchDates(t *testing.T) {+ for _, tt := range []struct {+ name string+ published string+ lastCrawled string+ includeDate bool+ want string+ }{+ {"legacy fallback", "", "2026-08-09T02:18:30Z", true, "2026-08-08T18:18:30Z"},+ {"invalid published fallback", "invalid", " 2026-08-09T02:18:30.123Z ", true, "2026-08-08T18:18:30.123Z"},+ {"published UTC preferred", "2026-08-09T02:18:30Z", "2026-08-09T02:18:30Z", true, "2026-08-09T02:18:30Z"},+ {"published explicit offset", "2026-08-09T02:18:30+08:00", "invalid", true, "2026-08-08T18:18:30Z"},+ {"fallback explicit offset", "", "2026-08-09T02:18:30+08:00", true, "2026-08-08T18:18:30Z"},+ {"invalid dates", "invalid", "invalid", true, ""},+ {"date excluded", "2026-08-09T02:18:30+08:00", "2026-08-09T02:18:30Z", false, ""},+ } {+ t.Run(tt.name, func(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ var response bochaSearchResponse+ response.Code = 200+ response.Data.WebPages.Value = []bochaWebPage{{+ Name: "Result", URL: "https://example.com",+ DatePublished: tt.published, DateLastCrawled: tt.lastCrawled,+ }}+ w.Header().Set("Content-Type", "application/json")+ if err := json.NewEncoder(w).Encode(response); err != nil {+ t.Error(err)+ }+ }))+ defer server.Close()+ bocha := &BochaProvider{+ client: server.Client(), baseURL: server.URL, apiKey: "sk-test", freshness: defaultBochaFreshness,+ }+ results, err := bocha.Search(context.Background(), "test", 1, tt.includeDate)+ if err != nil || len(results) != 1 {+ t.Fatalf("results = %v, err = %v", results, err)+ }+ got := results[0].PublishedAt+ if tt.want == "" {+ if got != nil {+ t.Fatalf("date = %v, want nil", got)+ }+ return+ }+ if got == nil || got.UTC().Format(time.RFC3339Nano) != tt.want {+ t.Fatalf("date = %v, want %s", got, tt.want)+ }+ })+ }+}++func TestValidateBochaParameters(t *testing.T) {+ if err := ValidateBochaParameters(types.WebSearchProviderParameters{}); err == nil {+ t.Fatal("expected missing API key error")+ }+ if err := ValidateBochaParameters(types.WebSearchProviderParameters{APIKey: "sk-test", ExtraConfig: map[string]string{"freshness": "oneHour"}}); err == nil {+ t.Fatal("expected invalid freshness error")+ }+ if err := ValidateBochaParameters(types.WebSearchProviderParameters{APIKey: "sk-test"}); err != nil {+ t.Fatalf("default parameters: %v", err)+ }+}++func TestBochaProviderHTTPError(t *testing.T) {+ // Error body captured from the live API (2026-09-05): the message field is+ // "message" and the code is a JSON string.+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ w.WriteHeader(http.StatusUnauthorized)+ _, _ = w.Write([]byte(`{"log_id":"4a995aed60e4088e","message":"Invalid API KEY","code":"401"}`))+ }))+ defer server.Close()+ bocha := &BochaProvider{client: server.Client(), baseURL: server.URL, apiKey: "bad", freshness: defaultBochaFreshness, summary: true}+ _, err := bocha.Search(context.Background(), "test", 1, false)+ if err == nil || !strings.Contains(err.Error(), "Invalid API KEY") {+ t.Fatalf("error = %v", err)+ }+}++func TestBochaProviderAPIErrorWithHTTPOK(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ w.Header().Set("Content-Type", "application/json")+ _, _ = w.Write([]byte(`{"code":"429","message":"rate limited"}`))+ }))+ defer server.Close()+ bocha := &BochaProvider{client: server.Client(), baseURL: server.URL, apiKey: "sk-test", freshness: defaultBochaFreshness, summary: true}+ _, err := bocha.Search(context.Background(), "test", 1, false)+ if err == nil || !strings.Contains(err.Error(), "429") {+ t.Fatalf("error = %v", err)+ }+}++func TestBochaProviderSearchAcceptsStringAndNumericCode(t *testing.T) {+ for _, body := range []string{+ `{"code":"200","data":{"webPages":{"value":[{"name":"A","url":"https://example.com/a","snippet":"s1"}]}}}`,+ `{"code":200,"data":{"webPages":{"value":[{"name":"B","url":"https://example.com/b","snippet":"s2"}]}}}`,+ } {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ w.Header().Set("Content-Type", "application/json")+ _, _ = w.Write([]byte(body))+ }))+ bocha := &BochaProvider{client: server.Client(), baseURL: server.URL, apiKey: "sk-test", freshness: defaultBochaFreshness, summary: true}+ results, err := bocha.Search(context.Background(), "test", 1, false)+ if err != nil || len(results) != 1 {+ t.Fatalf("body %s: results = %v, err = %v", body, results, err)+ }+ server.Close()+ }+}diff --git a/internal/types/web_search_provider.go b/internal/types/web_search_provider.goindex 0a21cfbc6..d9d376ee6 100644--- a/internal/types/web_search_provider.go+++ b/internal/types/web_search_provider.go@@ -26,6 +26,7 @@ const (WebSearchProviderTypeZhipu WebSearchProviderType = "zhipu"WebSearchProviderTypeExa WebSearchProviderType = "exa"WebSearchProviderTypeMetaso WebSearchProviderType = "metaso"+ WebSearchProviderTypeBocha WebSearchProviderType = "bocha")// WebSearchProviderEntity represents a configured web search provider instance for a workspace.@@ -324,5 +325,41 @@ func GetWebSearchProviderTypes() []WebSearchProviderTypeInfo {},},},+ {+ ID: "bocha",+ Name: "Bocha AI Search",+ RequiresAPIKey: true,+ SupportsProxy: true,+ Description: "Bocha AI Web Search API (requires API key)",+ DocsURL: "https://open.bochaai.com/",+ ConfigFields: []WebSearchProviderConfigField{+ {+ Key: "freshness",+ Label: "Freshness",+ Type: "select",+ Required: true,+ Default: "noLimit",+ Description: "Time range filter applied by Bocha; noLimit is recommended.",+ Options: []WebSearchProviderConfigFieldOption{+ {Label: "No limit", Value: "noLimit"},+ {Label: "Past day", Value: "oneDay"},+ {Label: "Past week", Value: "oneWeek"},+ {Label: "Past month", Value: "oneMonth"},+ {Label: "Past year", Value: "oneYear"},+ },+ },+ {+ Key: "summary",+ Label: "Summary",+ Type: "select",+ Default: "true",+ Description: "Request long text summaries and prefer them as result snippets.",+ Options: []WebSearchProviderConfigFieldOption{+ {Label: "Enabled", Value: "true"},+ {Label: "Disabled", Value: "false"},+ },+ },+ },+ },}}diff --git a/internal/types/web_search_provider_test.go b/internal/types/web_search_provider_test.goindex 43fa4d90a..7da74d0df 100644--- a/internal/types/web_search_provider_test.go+++ b/internal/types/web_search_provider_test.go@@ -76,3 +76,27 @@ func TestGetWebSearchProviderTypesIncludesMetaso(t *testing.T) {t.Fatalf("unexpected Metaso scope metadata: %+v", field)}}++func TestGetWebSearchProviderTypesIncludesBocha(t *testing.T) {+ var bocha *WebSearchProviderTypeInfo+ providerTypes := GetWebSearchProviderTypes()+ for i := range providerTypes {+ if providerTypes[i].ID == string(WebSearchProviderTypeBocha) {+ bocha = &providerTypes[i]+ break+ }+ }+ if bocha == nil {+ t.Fatal("Bocha provider type not found")+ }+ if !bocha.RequiresAPIKey || !bocha.SupportsProxy || len(bocha.ConfigFields) != 2 {+ t.Fatalf("unexpected Bocha metadata: %+v", bocha)+ }+ freshness := bocha.ConfigFields[0]+ if freshness.Key != "freshness" || freshness.Default != "noLimit" || len(freshness.Options) != 5 {+ t.Fatalf("unexpected Bocha freshness metadata: %+v", freshness)+ }+ if summary := bocha.ConfigFields[1]; summary.Key != "summary" || summary.Default != "true" {+ t.Fatalf("unexpected Bocha summary metadata: %+v", summary)+ }+}