opencode/yao
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix(tests): temporarily disable KB/DB search in tests

Browse source 
- Skipped tests related to KB/DB search functionality due to temporary unavailability.
- Updated test cases in chat_test.go, search_auth_integration_test.go, search_auto_full_test.go, and others to reflect this change.
- Adjusted search handling in search.go to limit search types to "web" only until KB/DB search is re-enabled.
This commit is contained in:
Max 2026-05-03 10:26:06 +08:00
parent fb01a1c141
commit 7877797549
25 changed files with 889 additions and 515 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
agent/assistant/chat_test.go
View file

@ -18,6 +18,7 @@ import (
)
func TestGetChatKBID(t *testing.T) {
t.Skip("KB/DB search temporarily disabled")
t.Run("WithTeamAndUser", func(t *testing.T) {
teamID := "5659-5504-2879"
userID := "4287-9400-2030-0504"
@ -81,6 +82,7 @@ func TestGetChatKBID(t *testing.T) {
}
func TestPrepareKBCollection(t *testing.T) {
t.Skip("KB/DB search temporarily disabled")
testutils.Prepare(t)
defer testutils.Clean(t)

12
agent/assistant/mcp.go
View file

@ -552,7 +552,7 @@ func (ast *Assistant) executeServerToolsParallelWithTrace(mcpCtx context.Context
// Prepare parallel trace inputs
var parallelInputs []types.TraceParallelInput
mcpCalls := make([]mcpTypes.ToolCall, 0, len(toolCalls))
callMap := make(map[string]agentContext.ToolCall)
orderedCalls := make([]agentContext.ToolCall, 0, len(toolCalls))
for _, tc := range toolCalls {
_, toolName, ok := ParseMCPToolName(tc.Function.Name)
@ -572,7 +572,7 @@ func (ast *Assistant) executeServerToolsParallelWithTrace(mcpCtx context.Context
Name: toolName,
Arguments: args,
})
callMap[toolName] = tc
orderedCalls = append(orderedCalls, tc)
ctx.Logger.ToolStart(tc.Function.Name)
// Add trace input for this tool
@ -613,10 +613,8 @@ func (ast *Assistant) executeServerToolsParallelWithTrace(mcpCtx context.Context
if node != nil {
node.Fail(err)
}
if i < len(mcpCalls) {
if tc, ok := callMap[mcpCalls[i].Name]; ok {
ctx.Logger.ToolComplete(tc.Function.Name, false)
}
if i < len(orderedCalls) {
ctx.Logger.ToolComplete(orderedCalls[i].Function.Name, false)
}
}
return nil, true
@ -628,7 +626,7 @@ func (ast *Assistant) executeServerToolsParallelWithTrace(mcpCtx context.Context
for i, mcpResult := range mcpResponse.Results {
toolName := mcpCalls[i].Name
originalCall := callMap[toolName]
originalCall := orderedCalls[i]
var toolNode types.Node
if i < len(toolNodes) {
toolNode = toolNodes[i]

2
agent/assistant/search.go
View file

@ -91,7 +91,7 @@ func parseSearchField(search any) *SearchIntent {
if v {
return &SearchIntent{
NeedSearch: true,
SearchTypes: []string{"web", "kb", "db"},
SearchTypes: []string{"web"}, // TODO: 恢复 KB/DB 搜索时改回 []string{"web", "kb", "db"}
Confidence: 1.0,
Reason: "enabled by hook",
}

3
agent/assistant/search_auth_integration_test.go
View file

@ -62,6 +62,7 @@ func (c *authTestCollections) cleanup(ctx context.Context, t *testing.T) {
// FilterKBCollectionsByAuth filters collections based on user authorization.
func TestKBCollectionAuthFilter(t *testing.T) {
t.Skip("KB/DB search temporarily disabled")
testutils.Prepare(t)
defer testutils.Clean(t)
@ -155,6 +156,7 @@ func TestKBCollectionAuthFilter(t *testing.T) {
// ========== DB Auth Wheres Tests ==========
func TestDBAuthWheresFilter(t *testing.T) {
t.Skip("KB/DB search temporarily disabled")
// Note: This test doesn't need KB, just tests the BuildDBAuthWheres function
t.Run("TeamOnlyGeneratesCorrectWheres", func(t *testing.T) {
ctx := createAuthContext(TestUserA, TestTeam1, true, false)
@ -273,6 +275,7 @@ func TestDBAuthWheresFilter(t *testing.T) {
// ========== KB Search Integration Tests ==========
func TestKBSearchIntegration(t *testing.T) {
t.Skip("KB/DB search temporarily disabled")
testutils.Prepare(t)
defer testutils.Clean(t)

6
agent/assistant/search_auto_full_test.go
View file

@ -52,23 +52,28 @@ func TestSearchAutoFull(t *testing.T) {
assert.Equal(t, 3, ast.Search.Web.MaxResults)
})
// KB/DB search temporarily disabled
t.Run("ShouldHaveKBSearchConfig", func(t *testing.T) {
t.Skip("KB/DB search temporarily disabled")
assert.NotNil(t, ast.Search.KB, "kb search config should be set")
assert.Equal(t, 0.7, ast.Search.KB.Threshold)
assert.False(t, ast.Search.KB.Graph)
})
t.Run("ShouldHaveDBSearchConfig", func(t *testing.T) {
t.Skip("KB/DB search temporarily disabled")
assert.NotNil(t, ast.Search.DB, "db search config should be set")
assert.Equal(t, 10, ast.Search.DB.MaxResults)
})
t.Run("ShouldHaveKBCollections", func(t *testing.T) {
t.Skip("KB/DB search temporarily disabled")
assert.NotNil(t, ast.KB, "kb config should be set")
assert.Contains(t, ast.KB.Collections, "test-collection")
})
t.Run("ShouldHaveDBModels", func(t *testing.T) {
t.Skip("KB/DB search temporarily disabled")
assert.NotNil(t, ast.DB, "db config should be set")
assert.Contains(t, ast.DB.Models, "user")
assert.Contains(t, ast.DB.Models, "article")
@ -87,6 +92,7 @@ func TestSearchAutoFull(t *testing.T) {
})
t.Run("StreamShouldExecuteMultipleSearchTypes", func(t *testing.T) {
t.Skip("KB/DB search temporarily disabled")
// Get agent via assistant.Get (required for Stream)
agent, err := assistant.Get("tests.search-auto-full")
require.NoError(t, err)

772
data/bindata.go
View file

File diff suppressed because one or more lines are too long

6
tools/docs/docs.go
View file

@ -16,7 +16,7 @@ var InspectSchemaJSON []byte
//go:embed validate.json
var ValidateSchemaJSON []byte
// ListHandler is the tools.doclist process handler.
// ListHandler is the tools.doc_list process handler.
// Args[0]: keyword (string, optional — empty lists all)
// Args[1]: limit (int, default 20)
func ListHandler(proc *process.Process) interface{} {
@ -35,7 +35,7 @@ func ListHandler(proc *process.Process) interface{} {
return results
}
// InspectHandler is the tools.docinspect process handler.
// InspectHandler is the tools.doc_inspect process handler.
// Args[0]: name (string — process name, e.g. "models.user.Find")
func InspectHandler(proc *process.Process) interface{} {
name := proc.ArgsString(0)
@ -46,7 +46,7 @@ func InspectHandler(proc *process.Process) interface{} {
return entry
}
// ValidateHandler is the tools.docvalidate process handler.
// ValidateHandler is the tools.doc_validate process handler.
// Args[0]: name (string — process name)
func ValidateHandler(proc *process.Process) interface{} {
name := proc.ArgsString(0)

12
tools/docs/docs_test.go
View file

@ -31,7 +31,7 @@ func init() {
}
func TestListHandler_All(t *testing.T) {
proc := process.New("tools.doclist", "", 20)
proc := process.New("tools.doc_list", "", 20)
result := ListHandler(proc)
entries, ok := result.([]*goudoc.Entry)
if !ok {
@ -43,7 +43,7 @@ func TestListHandler_All(t *testing.T) {
}
func TestListHandler_Search(t *testing.T) {
proc := process.New("tools.doclist", "Find", 10)
proc := process.New("tools.doc_list", "Find", 10)
result := ListHandler(proc)
entries, ok := result.([]*goudoc.Entry)
if !ok {
@ -58,7 +58,7 @@ func TestListHandler_Search(t *testing.T) {
}
func TestInspectHandler(t *testing.T) {
proc := process.New("tools.docinspect", "models.Find")
proc := process.New("tools.doc_inspect", "models.Find")
result := InspectHandler(proc)
if result == nil {
t.Fatal("expected non-nil result for models.Find")
@ -73,7 +73,7 @@ func TestInspectHandler(t *testing.T) {
}
func TestInspectHandler_NotFound(t *testing.T) {
proc := process.New("tools.docinspect", "nonexistent.process")
proc := process.New("tools.doc_inspect", "nonexistent.process")
result := InspectHandler(proc)
if result != nil {
t.Error("expected nil for non-existent process")
@ -81,7 +81,7 @@ func TestInspectHandler_NotFound(t *testing.T) {
}
func TestValidateHandler_Valid(t *testing.T) {
proc := process.New("tools.docvalidate", "models.Find")
proc := process.New("tools.doc_validate", "models.Find")
result := ValidateHandler(proc)
if result == nil {
t.Fatal("expected non-nil result")
@ -96,7 +96,7 @@ func TestValidateHandler_Valid(t *testing.T) {
}
func TestValidateHandler_Invalid(t *testing.T) {
proc := process.New("tools.docvalidate", "nonexistent.process")
proc := process.New("tools.doc_validate", "nonexistent.process")
result := ValidateHandler(proc)
if result == nil {
t.Fatal("expected non-nil result")

4
tools/docs/inspect.json
View file

@ -1,7 +1,7 @@
{
"name": "docinspect",
"name": "doc_inspect",
"description": "Get detailed documentation for a specific Yao process, including arguments, return type, and methods.",
"process": "tools.docinspect",
"process": "tools.doc_inspect",
"inputSchema": {
"type": "object",
"properties": {

4
tools/docs/list.json
View file

@ -1,7 +1,7 @@
{
"name": "doclist",
"name": "doc_list",
"description": "List or search Yao process documentation. Returns matching entries with name, group, and description.",
"process": "tools.doclist",
"process": "tools.doc_list",
"inputSchema": {
"type": "object",
"properties": {

4
tools/docs/validate.json
View file

@ -1,7 +1,7 @@
{
"name": "docvalidate",
"name": "doc_validate",
"description": "Check if a Yao process has documentation. Returns validation status and suggestions for similar processes if not found.",
"process": "tools.docvalidate",
"process": "tools.doc_validate",
"inputSchema": {
"type": "object",
"properties": {

6
tools/mcps/doc.json
View file

@ -3,8 +3,8 @@
"transport": "process",
"description": "Yao process documentation tools",
"tools": {
"doclist": "tools.doclist",
"docinspect": "tools.docinspect",
"docvalidate": "tools.docvalidate"
"doc_list": "tools.doc_list",
"doc_inspect": "tools.doc_inspect",
"doc_validate": "tools.doc_validate"
}
}

3
tools/mcps/process.json
View file

@ -3,6 +3,7 @@
"transport": "process",
"description": "Yao process execution tool",
"tools": {
"processcall": "tools.processcall"
"process_call": "tools.process_call",
"process_allowed": "tools.process_allowed"
}
}

4
tools/mcps/web.json
View file

@ -3,7 +3,7 @@
"transport": "process",
"description": "Web search and fetch tools",
"tools": {
"websearch": "tools.websearch",
"webfetch": "tools.webfetch"
"web_search": "tools.web_search",
"web_fetch": "tools.web_fetch"
}
}

15
tools/proc/allowed.json Normal file
View file

@ -0,0 +1,15 @@
{
"name": "process_allowed",
"description": "Check which processes are allowed for process_call. Without a name, returns all allowed rules. With a name, checks if that specific process is allowed.",
"process": "tools.process_allowed",
"inputSchema": {
"type": "object",
"properties": {
"name": {
"type": "string",
"description": "Process name to check (optional, omit to list all rules)"
}
}
},
"x-process-args": ["$args.name"]
}

127
tools/proc/proc.go
View file

@ -3,36 +3,74 @@ package proc
import (
_ "embed"
"strings"
"sync"
"github.com/yaoapp/gou/application"
"github.com/yaoapp/gou/process"
"github.com/yaoapp/kun/exception"
"github.com/yaoapp/kun/log"
)
//go:embed schema.json
var SchemaJSON []byte
// Allowed process prefixes — blocks system/internal processes.
var allowedPrefixes = []string{
"models.",
"schemas.",
"stores.",
"flows.",
"scripts.",
"utils.",
//go:embed allowed.json
var AllowedSchemaJSON []byte
// Config is the tools.yml configuration structure.
// Extensible for future tool settings (web_search, web_fetch, etc.)
type Config struct {
ProcessCall ProcessCallConfig `json:"process_call" yaml:"process_call"`
}
// ProcessCallConfig defines the allowed process list for process_call.
type ProcessCallConfig struct {
Allowed []string `json:"allowed" yaml:"allowed"`
}
// Default allowed prefixes when no tools.yml is present.
var defaultAllowed = []string{
"http.",
"encoding.",
"json.",
"text.",
}
// Explicitly blocked prefixes for safety.
var blockedPrefixes = []string{
"yao.sys.",
"yao.env.",
"tools.",
var (
config *Config
configOnce sync.Once
)
// LoadConfig loads tools.yml from the application root.
// If tools.yml exists, its process_call.allowed completely replaces the default list.
// If tools.yml does not exist, the default safe list is used.
func LoadConfig() {
configOnce.Do(func() {
if application.App == nil {
return
}
// Handler is the tools.processcall process handler.
data, err := application.App.Read("tools.yml")
if err != nil {
return
}
cfg := &Config{}
if err := application.Parse("tools.yml", data, cfg); err != nil {
log.Error("[tools] failed to parse tools.yml: %s", err.Error())
return
}
config = cfg
log.Info("[tools] loaded tools.yml with %d process_call rules", len(cfg.ProcessCall.Allowed))
})
}
// Handler is the tools.process_call process handler.
// Args[0]: name (string — process name, e.g. "models.user.Find")
// Args[1]: args ([]interface{} — process arguments, optional)
func Handler(p *process.Process) interface{} {
LoadConfig()
name := p.ArgsString(0)
if !isAllowedProcess(name) {
@ -62,20 +100,69 @@ func Handler(p *process.Process) interface{} {
return target.Value()
}
// AllowedHandler is the tools.process_allowed process handler.
// Without args: returns the current allowed rules list.
// Args[0]: name (string) — check if a specific process is allowed, returns {"allowed": bool, "name": string}.
func AllowedHandler(p *process.Process) interface{} {
LoadConfig()
name := ""
if len(p.Args) > 0 {
name = p.ArgsString(0)
}
if name != "" {
return map[string]interface{}{
"name": name,
"allowed": isAllowedProcess(name),
}
}
rules := defaultAllowed
if config != nil && len(config.ProcessCall.Allowed) > 0 {
rules = config.ProcessCall.Allowed
}
return map[string]interface{}{
"rules": rules,
}
}
func isAllowedProcess(name string) bool {
lower := strings.ToLower(name)
for _, prefix := range blockedPrefixes {
if strings.HasPrefix(lower, prefix) {
return false
}
// If tools.yml was loaded, use its rules exclusively
if config != nil && len(config.ProcessCall.Allowed) > 0 {
return matchRules(lower, config.ProcessCall.Allowed)
}
for _, prefix := range allowedPrefixes {
// Otherwise use default safe list
return matchRules(lower, defaultAllowed)
}
// matchRules checks name against a list of rules.
// Rules ending with "*" do prefix matching (e.g. "models.*" matches "models.user.find").
// Rules ending with "." also do prefix matching (e.g. "http." matches "http.get").
// Other rules do exact matching (e.g. "models.user.Find" matches only that).
func matchRules(lower string, rules []string) bool {
for _, rule := range rules {
r := strings.ToLower(rule)
if strings.HasSuffix(r, ".*") {
// "models.*" → prefix match on "models."
prefix := r[:len(r)-1] // "models."
if strings.HasPrefix(lower, prefix) {
return true
}
} else if strings.HasSuffix(r, ".") {
// "http." → prefix match
if strings.HasPrefix(lower, r) {
return true
}
} else {
// Exact match
if lower == r {
return true
}
}
}
return false
}

314
tools/proc/proc_test.go
View file

@ -1,39 +1,323 @@
package proc
import (
"sync"
"testing"
"github.com/yaoapp/gou/process"
)
func TestIsAllowedProcess(t *testing.T) {
func TestDefaultAllowed(t *testing.T) {
resetConfig()
allowed := []string{
"models.user.Find",
"schemas.user.Setting",
"stores.cache.Set",
"flows.login.Run",
"scripts.helper.Format",
"services.user.Create",
"tasks.send.Run",
"schedules.cleanup.Run",
"widgets.chart.Data",
"http.Get",
"http.post",
"encoding.json.Encode",
"encoding.base64.Decode",
"json.parse",
"json.validate",
"text.extract",
"text.htmltomarkdown",
}
for _, name := range allowed {
if !isAllowedProcess(name) {
t.Errorf("expected %q to be allowed", name)
t.Errorf("expected %q to be allowed by default", name)
}
}
}
func TestIsBlockedProcess(t *testing.T) {
func TestDefaultBlocked(t *testing.T) {
resetConfig()
blocked := []string{
"utils.str.Join",
"utils.app.Inspect",
"models.user.Find",
"model.load",
"schemas.default.tablecreate",
"stores.cache.Set",
"flows.login.Run",
"scripts.helper.Format",
"yao.sys.Exec",
"yao.env.Get",
"utils.str.Join",
"tools.websearch",
"tools.web_search",
"fs.system.readfile",
"unknown.process",
}
for _, name := range blocked {
if isAllowedProcess(name) {
t.Errorf("expected %q to be blocked", name)
t.Errorf("expected %q to be blocked by default", name)
}
}
}
func TestAppConfigReplacesDefault(t *testing.T) {
resetConfig()
config = &Config{
ProcessCall: ProcessCallConfig{
Allowed: []string{
"models.*",
"scripts.*",
"flows.*",
"http.*",
"stores.cache.*",
},
},
}
allowed := []string{
"models.user.Find",
"models.order.Create",
"scripts.helper.Format",
"flows.login.Run",
"http.Get",
"stores.cache.Set",
"stores.cache.Get",
}
for _, name := range allowed {
if !isAllowedProcess(name) {
t.Errorf("expected %q to be allowed with app config", name)
}
}
blocked := []string{
"encoding.json.Encode",
"json.parse",
"text.extract",
"utils.str.Join",
"stores.session.Set",
"yao.sys.Exec",
}
for _, name := range blocked {
if isAllowedProcess(name) {
t.Errorf("expected %q to be blocked with app config (not in tools.yml)", name)
}
}
}
func TestExactMatch(t *testing.T) {
resetConfig()
config = &Config{
ProcessCall: ProcessCallConfig{
Allowed: []string{
"models.user.Find",
"models.user.Get",
"scripts.auth.Login",
},
},
}
allowed := []string{
"models.user.Find",
"models.user.Get",
"scripts.auth.Login",
}
for _, name := range allowed {
if !isAllowedProcess(name) {
t.Errorf("expected %q to be allowed by exact match", name)
}
}
blocked := []string{
"models.user.Create",
"models.order.Find",
"scripts.auth.Logout",
"scripts.helper.Run",
}
for _, name := range blocked {
if isAllowedProcess(name) {
t.Errorf("expected %q to be blocked (not in exact match list)", name)
}
}
}
func TestCaseInsensitive(t *testing.T) {
resetConfig()
if !isAllowedProcess("HTTP.GET") {
t.Error("expected HTTP.GET to be allowed (case insensitive)")
}
if !isAllowedProcess("Json.Parse") {
t.Error("expected Json.Parse to be allowed (case insensitive)")
}
resetConfig()
config = &Config{
ProcessCall: ProcessCallConfig{
Allowed: []string{"Models.*", "scripts.Auth.Login"},
},
}
if !isAllowedProcess("models.user.Find") {
t.Error("expected models.user.Find to match Models.* (case insensitive)")
}
if !isAllowedProcess("Scripts.Auth.Login") {
t.Error("expected Scripts.Auth.Login to match scripts.Auth.Login (case insensitive)")
}
}
func TestMixedRules(t *testing.T) {
resetConfig()
config = &Config{
ProcessCall: ProcessCallConfig{
Allowed: []string{
"models.*",
"scripts.auth.Login",
"http.*",
},
},
}
allowed := []string{
"models.user.Find",
"models.order.Create",
"scripts.auth.Login",
"http.Get",
}
for _, name := range allowed {
if !isAllowedProcess(name) {
t.Errorf("expected %q to be allowed with mixed rules", name)
}
}
blocked := []string{
"scripts.auth.Logout",
"scripts.helper.Run",
"flows.login.Run",
}
for _, name := range blocked {
if isAllowedProcess(name) {
t.Errorf("expected %q to be blocked with mixed rules", name)
}
}
}
func TestEmptyConfig(t *testing.T) {
resetConfig()
config = &Config{
ProcessCall: ProcessCallConfig{
Allowed: []string{},
},
}
// Empty allowed list in config means nothing is allowed — falls through to default
if !isAllowedProcess("http.Get") {
t.Error("expected http.Get to be allowed when config has empty allowed list (default fallback)")
}
}
func TestAllowedHandlerListDefault(t *testing.T) {
resetConfig()
p := &process.Process{Args: []interface{}{}}
result := AllowedHandler(p)
m, ok := result.(map[string]interface{})
if !ok {
t.Fatalf("expected map result, got %T", result)
}
rules, ok := m["rules"]
if !ok {
t.Fatal("expected 'rules' key in result")
}
ruleSlice, ok := rules.([]string)
if !ok {
t.Fatalf("expected []string for rules, got %T", rules)
}
if len(ruleSlice) != len(defaultAllowed) {
t.Errorf("expected %d default rules, got %d", len(defaultAllowed), len(ruleSlice))
}
for i, r := range defaultAllowed {
if ruleSlice[i] != r {
t.Errorf("rule[%d]: expected %q, got %q", i, r, ruleSlice[i])
}
}
}
func TestAllowedHandlerListCustomConfig(t *testing.T) {
resetConfig()
config = &Config{
ProcessCall: ProcessCallConfig{
Allowed: []string{"models.*", "scripts.*", "http.*"},
},
}
p := &process.Process{Args: []interface{}{}}
result := AllowedHandler(p)
m, ok := result.(map[string]interface{})
if !ok {
t.Fatalf("expected map result, got %T", result)
}
rules := m["rules"].([]string)
expected := []string{"models.*", "scripts.*", "http.*"}
if len(rules) != len(expected) {
t.Errorf("expected %d rules, got %d", len(expected), len(rules))
}
for i, r := range expected {
if rules[i] != r {
t.Errorf("rule[%d]: expected %q, got %q", i, r, rules[i])
}
}
}
func TestAllowedHandlerCheckAllowed(t *testing.T) {
resetConfig()
p := &process.Process{Args: []interface{}{"http.Get"}}
result := AllowedHandler(p)
m, ok := result.(map[string]interface{})
if !ok {
t.Fatalf("expected map result, got %T", result)
}
if m["name"] != "http.Get" {
t.Errorf("expected name 'http.Get', got %v", m["name"])
}
if m["allowed"] != true {
t.Error("expected http.Get to be allowed")
}
}
func TestAllowedHandlerCheckBlocked(t *testing.T) {
resetConfig()
p := &process.Process{Args: []interface{}{"models.user.Find"}}
result := AllowedHandler(p)
m, ok := result.(map[string]interface{})
if !ok {
t.Fatalf("expected map result, got %T", result)
}
if m["name"] != "models.user.Find" {
t.Errorf("expected name 'models.user.Find', got %v", m["name"])
}
if m["allowed"] != false {
t.Error("expected models.user.Find to be blocked by default")
}
}
func TestAllowedHandlerCheckWithConfig(t *testing.T) {
resetConfig()
config = &Config{
ProcessCall: ProcessCallConfig{
Allowed: []string{"models.*", "scripts.auth.Login"},
},
}
// Prefix match
p := &process.Process{Args: []interface{}{"models.user.Find"}}
result := AllowedHandler(p).(map[string]interface{})
if result["allowed"] != true {
t.Error("expected models.user.Find to be allowed with config")
}
// Exact match
p = &process.Process{Args: []interface{}{"scripts.auth.Login"}}
result = AllowedHandler(p).(map[string]interface{})
if result["allowed"] != true {
t.Error("expected scripts.auth.Login to be allowed with config")
}
// Not in config
p = &process.Process{Args: []interface{}{"http.Get"}}
result = AllowedHandler(p).(map[string]interface{})
if result["allowed"] != false {
t.Error("expected http.Get to be blocked (not in custom config)")
}
}
func resetConfig() {
config = nil
configOnce = sync.Once{}
}

4
tools/proc/schema.json
View file

@ -1,7 +1,7 @@
{
"name": "processcall",
"name": "process_call",
"description": "Execute a Yao process by name. Supports models, schemas, stores, flows, and scripts.",
"process": "tools.processcall",
"process": "tools.process_call",
"inputSchema": {
"type": "object",
"properties": {

15
tools/tools.go
View file

@ -25,18 +25,19 @@ var mcpDocDSL []byte
func init() {
process.RegisterGroup("tools", map[string]process.Handler{
"websearch": websearch.Handler,
"webfetch": webfetch.Handler,
"processcall": proc.Handler,
"doclist": docs.ListHandler,
"docinspect": docs.InspectHandler,
"docvalidate": docs.ValidateHandler,
"web_search": websearch.Handler,
"web_fetch": webfetch.Handler,
"process_call": proc.Handler,
"process_allowed": proc.AllowedHandler,
"doc_list": docs.ListHandler,
"doc_inspect": docs.InspectHandler,
"doc_validate": docs.ValidateHandler,
})
registerMCPServer(mcpWebDSL, "yao-web",
websearch.SchemaJSON, webfetch.SchemaJSON)
registerMCPServer(mcpProcessDSL, "yao-process",
proc.SchemaJSON)
proc.SchemaJSON, proc.AllowedSchemaJSON)
registerMCPServer(mcpDocDSL, "yao-doc",
docs.ListSchemaJSON, docs.InspectSchemaJSON, docs.ValidateSchemaJSON)
}

4
tools/webfetch/schema.json
View file

@ -1,7 +1,7 @@
{
"name": "webfetch",
"name": "web_fetch",
"description": "Fetch a web page and return its content. Supports markdown and HTML output formats.",
"process": "tools.webfetch",
"process": "tools.web_fetch",
"inputSchema": {
"type": "object",
"properties": {

2
tools/webfetch/webfetch.go
View file

@ -28,7 +28,7 @@ type fetchConfig struct {
BrightdataZone string
}
// Handler is the tools.webfetch process handler.
// Handler is the tools.web_fetch process handler.
// Args[0]: url (string)
// Args[1]: format (string, default "markdown")
func Handler(proc *process.Process) interface{} {

4
tools/websearch/schema.json
View file

@ -1,7 +1,7 @@
{
"name": "websearch",
"name": "web_search",
"description": "Search the web for real-time information. Returns structured results with title, URL, and content snippet.",
"process": "tools.websearch",
"process": "tools.web_search",
"inputSchema": {
"type": "object",
"properties": {

2
tools/websearch/websearch.go
View file

@ -27,7 +27,7 @@ type searchConfig struct {
CloudTool string // cloud search tool name, e.g. "serper-search", "tavily-search"
}
// Handler is the tools.websearch process handler.
// Handler is the tools.web_search process handler.
// Args[0]: query (string)
// Args[1]: limit (int, default 10)
func Handler(proc *process.Process) interface{} {

57
yao/assistants/needsearch/prompts.yml
View file

@ -1,57 +1,34 @@
# Need Search Agent
- role: system
content: |
You are a search intent classifier. Analyze user input and classify whether external search is needed.
You are a search intent classifier. Determine whether a web search is needed to answer the user's query.
## Your Task
- Classify the user's query into search categories
- Output MUST be a JSON with exactly these 3 fields: need_search, search_types, confidence
- DO NOT extract keywords, DO NOT answer the question, DO NOT add explanations
## Output Format (JSON only, no markdown)
{"need_search": true/false, "search_types": ["web"], "confidence": 0.0-1.0}
## Classification Rules
## Rules
### need_search=false (No search needed)
Use when the question can be answered from LLM's internal knowledge:
- Greetings & chitchat: "hello", "how are you", casual conversation
- Math & calculations: arithmetic, equations, formulas
- Code generation: write code, debug, explain code, algorithms
- Text processing: translate, summarize, rewrite, format
- General knowledge: history, science, concepts (not time-sensitive)
- Creative tasks: write stories, poems, brainstorm ideas
- Reasoning & logic: philosophy, opinions, hypothetical questions
### need_search=true with search_types=["web"] (Web search)
### need_search=true (Web search needed)
Use when real-time or frequently changing information is needed:
- Current events: news, breaking stories, recent happenings
- Current events, news, breaking stories
- Time-sensitive data: weather, stock prices, exchange rates, sports scores
- Live information: event schedules, store hours, availability
- Recent updates: latest versions, new releases, current status
- Location-based: nearby places, local info, addresses
### need_search=true with search_types=["kb"] (Knowledge base)
Use when querying internal documentation or product knowledge:
- Documentation: how-to guides, tutorials, setup instructions
- Configuration: settings, parameters, options explained
- Product info: features, specifications, capabilities
- Policies: terms, rules, guidelines, compliance
- FAQ: common questions about the system/product
- Troubleshooting: error messages, known issues, solutions
### need_search=true with search_types=["db"] (Database)
Use when querying user-specific or transactional data:
- Personal data: "my orders", "my profile", "my history"
- Account info: balance, subscription, membership status
- Business records: invoices, transactions, payments
- User preferences: settings, saved items, favorites
- Keywords: "my", "mine", specific order/ID numbers
## Required Output Format (JSON only, no markdown)
{"need_search": true/false, "search_types": [], "confidence": 0.0-1.0}
### need_search=false (No search needed)
Use when the question can be answered from LLM's internal knowledge:
- Greetings & chitchat
- Math & calculations
- Code generation, debugging, algorithms
- Text processing: translate, summarize, rewrite
- General knowledge: history, science, concepts (not time-sensitive)
- Creative tasks: stories, poems, brainstorming
- Reasoning & logic
## Examples
"Hello" → {"need_search": false, "search_types": [], "confidence": 0.99}
"Today's weather" → {"need_search": true, "search_types": ["web"], "confidence": 0.95}
"Write a bubble sort in JS" → {"need_search": false, "search_types": [], "confidence": 0.95}
"用JavaScript写冒泡排序" → {"need_search": false, "search_types": [], "confidence": 0.95}
"How to config DB" → {"need_search": true, "search_types": ["kb"], "confidence": 0.85}
"My orders" → {"need_search": true, "search_types": ["db"], "confidence": 0.95}
"Latest news about AI" → {"need_search": true, "search_types": ["web"], "confidence": 0.95}
"How to config a database" → {"need_search": false, "search_types": [], "confidence": 0.90}

16
yao/assistants/needsearch/src/index.ts
View file

@ -50,7 +50,7 @@ function Next(
? parsed.search_types.filter(
(t) =>
typeof t === "string" &&
["web", "kb", "db"].includes(t.toLowerCase())
["web"].includes(t.toLowerCase()) // TODO: KB/DB search temporarily disabled. Original: ["web", "kb", "db"]
)
: [];
result.confidence =
@ -76,13 +76,12 @@ function extractFromText(text: string): SearchResult {
const lower = text.toLowerCase();
// Check for explicit indicators
// TODO: KB/DB search temporarily disabled. Original includes "kb" and "db".
const needSearch =
lower.includes("true") ||
lower.includes("need") ||
lower.includes("search") ||
lower.includes("web") ||
lower.includes("kb") ||
lower.includes("db");
lower.includes("web");
const noSearch =
lower.includes("false") ||
@ -90,12 +89,13 @@ function extractFromText(text: string): SearchResult {
lower.includes("not need");
// Extract search types
// TODO: KB/DB search temporarily disabled. Re-enable when ready.
const searchTypes: string[] = [];
if (lower.includes("web")) searchTypes.push("web");
if (lower.includes("kb") || lower.includes("knowledge"))
searchTypes.push("kb");
if (lower.includes("db") || lower.includes("database"))
searchTypes.push("db");
// if (lower.includes("kb") || lower.includes("knowledge"))
// searchTypes.push("kb");
// if (lower.includes("db") || lower.includes("database"))
// searchTypes.push("db");
// Determine need_search
const need = noSearch ? false : needSearch && searchTypes.length > 0;