diff --git a/agent/search/handlers/db/handler.go b/agent/search/handlers/db/handler.go
index 4736ff24..188c1b6c 100644
--- a/agent/search/handlers/db/handler.go
+++ b/agent/search/handlers/db/handler.go
@@ -1,8 +1,15 @@
 package db
 
 import (
+	"encoding/json"
+	"fmt"
 	"time"
 
+	"github.com/yaoapp/gou/model"
+	"github.com/yaoapp/gou/query"
+	"github.com/yaoapp/gou/query/gou"
+	agentContext "github.com/yaoapp/yao/agent/context"
+	"github.com/yaoapp/yao/agent/search/nlp/querydsl"
 	"github.com/yaoapp/yao/agent/search/types"
 )
 
@@ -23,8 +30,13 @@ func (h *Handler) Type() types.SearchType {
 }
 
 // Search converts NL to QueryDSL and executes
-// TODO: Implement actual QueryDSL generation and model query logic
+// Note: This method doesn't have context, use SearchWithContext for full functionality
 func (h *Handler) Search(req *types.Request) (*types.Result, error) {
+	return h.SearchWithContext(nil, req)
+}
+
+// SearchWithContext executes DB search with context (required for QueryDSL generation)
+func (h *Handler) SearchWithContext(ctx *agentContext.Context, req *types.Request) (*types.Result, error) {
 	start := time.Now()
 
 	// Validate request
@@ -41,13 +53,13 @@ func (h *Handler) Search(req *types.Request) (*types.Result, error) {
 	}
 
 	// Get models from request or config
-	models := req.Models
-	if len(models) == 0 && h.config != nil {
-		models = h.config.Models
+	modelIDs := req.Models
+	if len(modelIDs) == 0 && h.config != nil {
+		modelIDs = h.config.Models
 	}
 
 	// If no models specified, return empty result
-	if len(models) == 0 {
+	if len(modelIDs) == 0 {
 		return &types.Result{
 			Type:     types.SearchTypeDB,
 			Query:    req.Query,
@@ -55,6 +67,7 @@ func (h *Handler) Search(req *types.Request) (*types.Result, error) {
 			Items:    []*types.ResultItem{},
 			Total:    0,
 			Duration: time.Since(start).Milliseconds(),
+			Error:    "no models specified",
 		}, nil
 	}
 
@@ -67,27 +80,300 @@ func (h *Handler) Search(req *types.Request) (*types.Result, error) {
 		maxResults = 20 // default
 	}
 
-	// TODO: Implement actual DB search
-	// 1. Get model schemas for specified models
-	// 2. Generate QueryDSL from natural language query using uses.querydsl mode:
-	//    - "builtin": template-based generation
-	//    - "<assistant-id>": delegate to LLM assistant
-	//    - "mcp:<server>.<tool>": call external MCP tool
-	// 3. Execute QueryDSL on each model
-	// 4. Format results and return
+	// Context is required for QueryDSL generation
+	if ctx == nil {
+		return &types.Result{
+			Type:     types.SearchTypeDB,
+			Query:    req.Query,
+			Source:   req.Source,
+			Items:    []*types.ResultItem{},
+			Total:    0,
+			Duration: time.Since(start).Milliseconds(),
+			Error:    "context is required for DB search",
+		}, nil
+	}
 
-	// For now, return empty result (skeleton)
-	result := &types.Result{
+	// 1. Load all models and build combined schema
+	models := make(map[string]*model.Model)
+	schemas := make([]map[string]interface{}, 0, len(modelIDs))
+
+	for _, modelID := range modelIDs {
+		mod := model.Select(modelID)
+		if mod == nil {
+			continue // Skip non-existent models
+		}
+		models[modelID] = mod
+		schemas = append(schemas, h.buildModelSchema(mod))
+	}
+
+	if len(schemas) == 0 {
+		return &types.Result{
+			Type:     types.SearchTypeDB,
+			Query:    req.Query,
+			Source:   req.Source,
+			Items:    []*types.ResultItem{},
+			Total:    0,
+			Duration: time.Since(start).Milliseconds(),
+			Error:    "no valid models found",
+		}, nil
+	}
+
+	// 2. Generate QueryDSL with all schemas
+	generator := querydsl.NewGenerator(h.usesQueryDSL, nil)
+	input := &querydsl.Input{
+		Query:    req.Query,
+		ModelIDs: modelIDs,
+		Scenario: req.Scenario, // Pass scenario: filter, aggregation, join, complex
+		Limit:    maxResults,
+	}
+
+	// Build schema input: single schema or array of schemas
+	var schemaInput interface{}
+	if len(schemas) == 1 {
+		schemaInput = schemas[0]
+	} else {
+		schemaInput = schemas
+	}
+
+	input.ExtraParams = map[string]interface{}{
+		"schema": schemaInput,
+	}
+
+	result, err := generator.Generate(ctx, input)
+	if err != nil {
+		return &types.Result{
+			Type:     types.SearchTypeDB,
+			Query:    req.Query,
+			Source:   req.Source,
+			Items:    []*types.ResultItem{},
+			Total:    0,
+			Duration: time.Since(start).Milliseconds(),
+			Error:    fmt.Sprintf("QueryDSL generation failed: %v", err),
+		}, nil
+	}
+
+	if result == nil || result.DSL == nil {
+		return &types.Result{
+			Type:     types.SearchTypeDB,
+			Query:    req.Query,
+			Source:   req.Source,
+			Items:    []*types.ResultItem{},
+			Total:    0,
+			Duration: time.Since(start).Milliseconds(),
+			Error:    "no QueryDSL generated",
+		}, nil
+	}
+
+	// 3. Merge preset conditions into generated DSL
+	h.mergeDSLConditions(result.DSL, req)
+
+	// 4. Execute QueryDSL using gou query engine
+	records, err := h.executeDSL(result.DSL)
+	if err != nil {
+		return &types.Result{
+			Type:     types.SearchTypeDB,
+			Query:    req.Query,
+			Source:   req.Source,
+			Items:    []*types.ResultItem{},
+			Total:    0,
+			Duration: time.Since(start).Milliseconds(),
+			Error:    fmt.Sprintf("query execution failed: %v", err),
+		}, nil
+	}
+
+	// 5. Determine the primary model for result formatting
+	// Use the "from" table from DSL, or first model
+	primaryModelID := modelIDs[0]
+	if result.DSL.From != nil && result.DSL.From.Name != "" {
+		// Find model by table name
+		for id, mod := range models {
+			if mod.MetaData.Table.Name == result.DSL.From.Name {
+				primaryModelID = id
+				break
+			}
+		}
+	}
+
+	primaryModel := models[primaryModelID]
+	if primaryModel == nil {
+		primaryModel = model.Select(primaryModelID)
+	}
+
+	// 6. Convert records to ResultItems
+	items := h.convertToResultItems(records, primaryModelID, primaryModel, req.Source)
+
+	// Apply limit
+	if len(items) > maxResults {
+		items = items[:maxResults]
+	}
+
+	return &types.Result{
 		Type:     types.SearchTypeDB,
 		Query:    req.Query,
 		Source:   req.Source,
-		Items:    []*types.ResultItem{},
-		Total:    0,
+		Items:    items,
+		Total:    len(items),
 		Duration: time.Since(start).Milliseconds(),
+	}, nil
+}
+
+// mergeDSLConditions merges preset conditions from request into generated DSL
+func (h *Handler) mergeDSLConditions(dsl *gou.QueryDSL, req *types.Request) {
+	if dsl == nil {
+		return
 	}
 
-	// Store maxResults for later use
-	_ = maxResults
+	// Merge preset Wheres (prepend to ensure they take priority)
+	if len(req.Wheres) > 0 {
+		dsl.Wheres = append(req.Wheres, dsl.Wheres...)
+	}
 
-	return result, nil
+	// Merge preset Orders (prepend to ensure they take priority)
+	if len(req.Orders) > 0 {
+		dsl.Orders = append(req.Orders, dsl.Orders...)
+	}
+
+	// Merge preset Select fields
+	if len(req.Select) > 0 {
+		// Convert string fields to Expression
+		selectExprs := make([]gou.Expression, 0, len(req.Select))
+		for _, field := range req.Select {
+			selectExprs = append(selectExprs, gou.Expression{Field: field})
+		}
+		// If DSL has no select, use preset; otherwise merge
+		if len(dsl.Select) == 0 {
+			dsl.Select = selectExprs
+		} else {
+			// Prepend preset fields
+			dsl.Select = append(selectExprs, dsl.Select...)
+		}
+	}
+
+	// Ensure limit is set
+	if dsl.Limit == 0 && req.Limit > 0 {
+		dsl.Limit = req.Limit
+	}
+}
+
+// buildModelSchema builds a simplified schema for QueryDSL generator
+func (h *Handler) buildModelSchema(mod *model.Model) map[string]interface{} {
+	columns := make([]map[string]interface{}, 0, len(mod.Columns))
+	for _, col := range mod.Columns {
+		colInfo := map[string]interface{}{
+			"name": col.Name,
+			"type": col.Type,
+		}
+		if col.Label != "" {
+			colInfo["label"] = col.Label
+		}
+		if col.Description != "" {
+			colInfo["description"] = col.Description
+		}
+		columns = append(columns, colInfo)
+	}
+
+	return map[string]interface{}{
+		"name":    mod.MetaData.Table.Name,
+		"columns": columns,
+	}
+}
+
+// executeDSL executes the QueryDSL and returns records
+func (h *Handler) executeDSL(dsl interface{}) ([]map[string]interface{}, error) {
+	// Get the default query engine
+	engine, err := query.Select("default")
+	if err != nil {
+		return nil, fmt.Errorf("query engine not found: %w", err)
+	}
+
+	// Marshal DSL to JSON
+	dslJSON, err := json.Marshal(dsl)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal DSL: %w", err)
+	}
+
+	// Load and execute the query
+	q, err := engine.Load(json.RawMessage(dslJSON))
+	if err != nil {
+		return nil, fmt.Errorf("failed to load DSL: %w", err)
+	}
+
+	// Execute query
+	rawRecords := q.Get(nil)
+
+	// Convert to map[string]interface{}
+	records := make([]map[string]interface{}, 0, len(rawRecords))
+	for _, rec := range rawRecords {
+		records = append(records, map[string]interface{}(rec))
+	}
+
+	return records, nil
+}
+
+// convertToResultItems converts query results to ResultItems
+func (h *Handler) convertToResultItems(records []map[string]interface{}, modelID string, mod *model.Model, source types.SourceType) []*types.ResultItem {
+	items := make([]*types.ResultItem, 0, len(records))
+
+	primaryKey := "id"
+	if mod != nil && mod.PrimaryKey != "" {
+		primaryKey = mod.PrimaryKey
+	}
+
+	for _, rec := range records {
+		item := &types.ResultItem{
+			Type:   types.SearchTypeDB,
+			Source: source,
+			Model:  modelID,
+			Data:   rec,
+		}
+
+		// Try to extract title from common fields
+		item.Title = h.extractTitle(rec, mod)
+
+		// Try to extract content/description
+		item.Content = h.extractContent(rec, mod)
+
+		// Try to extract record ID
+		if id, ok := rec[primaryKey]; ok {
+			item.RecordID = id
+		}
+
+		items = append(items, item)
+	}
+
+	return items
+}
+
+// extractTitle tries to extract a title from the record
+func (h *Handler) extractTitle(rec map[string]interface{}, mod *model.Model) string {
+	// Common title fields
+	titleFields := []string{"title", "name", "subject", "label"}
+	for _, field := range titleFields {
+		if val, ok := rec[field]; ok {
+			if str, ok := val.(string); ok && str != "" {
+				return str
+			}
+		}
+	}
+	return ""
+}
+
+// extractContent tries to extract content from the record
+func (h *Handler) extractContent(rec map[string]interface{}, mod *model.Model) string {
+	// Common content fields
+	contentFields := []string{"content", "description", "summary", "text", "body"}
+	for _, field := range contentFields {
+		if val, ok := rec[field]; ok {
+			if str, ok := val.(string); ok && str != "" {
+				return str
+			}
+		}
+	}
+
+	// Fallback: serialize first few fields as content
+	content, _ := json.Marshal(rec)
+	if len(content) > 500 {
+		content = content[:500]
+	}
+	return string(content)
 }
diff --git a/agent/search/handlers/db/handler_integration_test.go b/agent/search/handlers/db/handler_integration_test.go
new file mode 100644
index 00000000..5d6bf2e5
--- /dev/null
+++ b/agent/search/handlers/db/handler_integration_test.go
@@ -0,0 +1,174 @@
+package db_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/yaoapp/gou/model"
+	"github.com/yaoapp/gou/query/gou"
+	"github.com/yaoapp/yao/agent/context"
+	"github.com/yaoapp/yao/agent/search/handlers/db"
+	"github.com/yaoapp/yao/agent/search/types"
+	"github.com/yaoapp/yao/agent/testutils"
+	oauthTypes "github.com/yaoapp/yao/openapi/oauth/types"
+)
+
+// ============================================================================
+// Integration Tests - Requires database and models
+// ============================================================================
+
+func TestHandler_Search_Integration(t *testing.T) {
+	// Skip if running short tests
+	if testing.Short() {
+		t.Skip("Skipping integration test")
+	}
+
+	// Initialize test environment (loads models, database, etc.)
+	testutils.Prepare(t)
+	defer testutils.Clean(t)
+
+	// Create test context
+	ctx := newTestContext(t)
+
+	// Verify __yao.role model is loaded
+	mod := model.Select("__yao.role")
+	require.NotNil(t, mod, "__yao.role model should be loaded")
+
+	t.Run("search_role_model_with_results", func(t *testing.T) {
+		// First, ensure there's at least one role in the database
+		ensureTestRole(t, mod)
+
+		// Create handler with builtin QueryDSL generator
+		h := db.NewHandler("builtin", &types.DBConfig{
+			Models:     []string{"__yao.role"},
+			MaxResults: 10,
+		})
+
+		req := &types.Request{
+			Type:     types.SearchTypeDB,
+			Query:    "查询所有角色",
+			Source:   types.SourceAuto,
+			Models:   []string{"__yao.role"},
+			Scenario: types.ScenarioFilter,
+			Limit:    10,
+		}
+
+		result, err := h.SearchWithContext(ctx, req)
+		require.NoError(t, err)
+		require.NotNil(t, result)
+
+		// Verify result structure
+		assert.Equal(t, types.SearchTypeDB, result.Type)
+		assert.Equal(t, "查询所有角色", result.Query)
+		assert.Equal(t, types.SourceAuto, result.Source)
+		assert.GreaterOrEqual(t, result.Duration, int64(0))
+
+		// Should have results
+		if result.Error != "" {
+			t.Logf("Search error: %s", result.Error)
+		}
+		assert.Empty(t, result.Error, "Search should not return error")
+		assert.Greater(t, len(result.Items), 0, "Should have at least one result")
+		assert.Equal(t, len(result.Items), result.Total)
+
+		// Verify result items
+		for _, item := range result.Items {
+			assert.Equal(t, types.SearchTypeDB, item.Type)
+			assert.Equal(t, types.SourceAuto, item.Source)
+			assert.Equal(t, "__yao.role", item.Model)
+			assert.NotNil(t, item.Data, "Data should not be nil")
+			assert.NotNil(t, item.RecordID, "RecordID should not be nil")
+		}
+	})
+
+	t.Run("search_with_filter_scenario", func(t *testing.T) {
+		h := db.NewHandler("builtin", nil)
+
+		req := &types.Request{
+			Type:     types.SearchTypeDB,
+			Query:    "查询系统角色",
+			Source:   types.SourceHook,
+			Models:   []string{"__yao.role"},
+			Scenario: types.ScenarioFilter,
+			Limit:    5,
+		}
+
+		result, err := h.SearchWithContext(ctx, req)
+		require.NoError(t, err)
+		require.NotNil(t, result)
+
+		assert.Equal(t, types.SearchTypeDB, result.Type)
+		assert.Equal(t, types.SourceHook, result.Source)
+		assert.LessOrEqual(t, len(result.Items), 5, "Should respect limit")
+	})
+
+	t.Run("search_with_preset_wheres", func(t *testing.T) {
+		h := db.NewHandler("builtin", nil)
+
+		req := &types.Request{
+			Type:   types.SearchTypeDB,
+			Query:  "查询角色",
+			Source: types.SourceAuto,
+			Models: []string{"__yao.role"},
+			Wheres: []gou.Where{
+				{Condition: gou.Condition{Field: &gou.Expression{Field: "is_active"}, Value: true, OP: "="}},
+			},
+			Limit: 10,
+		}
+
+		result, err := h.SearchWithContext(ctx, req)
+		require.NoError(t, err)
+		require.NotNil(t, result)
+
+		// All results should have is_active = true (due to preset where)
+		for _, item := range result.Items {
+			if data, ok := item.Data["is_active"]; ok {
+				// is_active could be bool or int depending on driver
+				switch v := data.(type) {
+				case bool:
+					assert.True(t, v)
+				case int64:
+					assert.Equal(t, int64(1), v)
+				case float64:
+					assert.Equal(t, float64(1), v)
+				}
+			}
+		}
+	})
+}
+
+// newTestContext creates a test context with required fields
+func newTestContext(t *testing.T) *context.Context {
+	t.Helper()
+	authorized := &oauthTypes.AuthorizedInfo{
+		UserID: "test-user",
+	}
+	chatID := "test-chat-db-search"
+	ctx := context.New(t.Context(), authorized, chatID)
+	return ctx
+}
+
+// ensureTestRole ensures there's at least one role in the database for testing
+func ensureTestRole(t *testing.T, mod *model.Model) {
+	t.Helper()
+
+	// Try to find existing roles
+	rows, err := mod.Get(model.QueryParam{Limit: 1})
+	if err == nil && len(rows) > 0 {
+		return // Already have roles
+	}
+
+	// Create a test role
+	_, err = mod.Create(map[string]interface{}{
+		"role_id":     "test_role",
+		"name":        "Test Role",
+		"description": "A test role for unit testing",
+		"is_active":   true,
+		"is_system":   false,
+		"level":       1,
+	})
+	if err != nil {
+		t.Logf("Note: Could not create test role: %v", err)
+	}
+}
diff --git a/agent/search/handlers/db/handler_test.go b/agent/search/handlers/db/handler_test.go
index 0ca5e4e5..67a91346 100644
--- a/agent/search/handlers/db/handler_test.go
+++ b/agent/search/handlers/db/handler_test.go
@@ -4,6 +4,8 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/yaoapp/gou/model"
+	"github.com/yaoapp/gou/query/gou"
 	"github.com/yaoapp/yao/agent/search/types"
 )
 
@@ -38,14 +40,13 @@ func TestHandler_Type(t *testing.T) {
 	assert.Equal(t, types.SearchTypeDB, h.Type())
 }
 
-func TestHandler_Search(t *testing.T) {
+func TestHandler_Search_Validation(t *testing.T) {
 	tests := []struct {
 		name         string
 		usesQueryDSL string
 		config       *types.DBConfig
 		req          *types.Request
 		expectError  string
-		expectItems  int
 	}{
 		{
 			name:         "empty query",
@@ -56,7 +57,6 @@ func TestHandler_Search(t *testing.T) {
 				Query: "",
 			},
 			expectError: "query is required",
-			expectItems: 0,
 		},
 		{
 			name:         "no models in request or config",
@@ -66,92 +66,20 @@ func TestHandler_Search(t *testing.T) {
 				Type:  types.SearchTypeDB,
 				Query: "find products under $100",
 			},
-			expectError: "",
-			expectItems: 0,
+			expectError: "no models specified",
 		},
 		{
-			name:         "models from config",
+			name:         "context required for DB search",
 			usesQueryDSL: "builtin",
 			config: &types.DBConfig{
-				Models:     []string{"product"},
-				MaxResults: 20,
+				Models: []string{"product"},
 			},
-			req: &types.Request{
-				Type:  types.SearchTypeDB,
-				Query: "find products under $100",
-			},
-			expectError: "",
-			expectItems: 0, // skeleton returns empty
-		},
-		{
-			name:         "models from request",
-			usesQueryDSL: "builtin",
-			config:       nil,
 			req: &types.Request{
 				Type:   types.SearchTypeDB,
 				Query:  "find products under $100",
-				Models: []string{"product", "order"},
-			},
-			expectError: "",
-			expectItems: 0, // skeleton returns empty
-		},
-		{
-			name:         "with limit",
-			usesQueryDSL: "builtin",
-			config: &types.DBConfig{
 				Models: []string{"product"},
 			},
-			req: &types.Request{
-				Type:   types.SearchTypeDB,
-				Query:  "find products",
-				Models: []string{"product"},
-				Limit:  5,
-			},
-			expectError: "",
-			expectItems: 0, // skeleton returns empty
-		},
-		{
-			name:         "with wheres",
-			usesQueryDSL: "builtin",
-			config: &types.DBConfig{
-				Models: []string{"product"},
-			},
-			req: &types.Request{
-				Type:   types.SearchTypeDB,
-				Query:  "find products",
-				Models: []string{"product"},
-				// Wheres would be set here in real usage
-			},
-			expectError: "",
-			expectItems: 0, // skeleton returns empty
-		},
-		{
-			name:         "agent mode",
-			usesQueryDSL: "workers.nlp.querydsl",
-			config: &types.DBConfig{
-				Models: []string{"product"},
-			},
-			req: &types.Request{
-				Type:   types.SearchTypeDB,
-				Query:  "find products",
-				Models: []string{"product"},
-			},
-			expectError: "",
-			expectItems: 0, // skeleton returns empty
-		},
-		{
-			name:         "mcp mode",
-			usesQueryDSL: "mcp:nlp.generate_querydsl",
-			config: &types.DBConfig{
-				Models: []string{"product"},
-			},
-			req: &types.Request{
-				Type:   types.SearchTypeDB,
-				Query:  "find products",
-				Models: []string{"product"},
-			},
-			expectError: "",
-			expectItems: 0, // skeleton returns empty
+			expectError: "context is required for DB search",
 		},
 	}
 
@@ -163,16 +91,8 @@ func TestHandler_Search(t *testing.T) {
 			assert.NoError(t, err)
 			assert.NotNil(t, result)
 			assert.Equal(t, types.SearchTypeDB, result.Type)
-			assert.Equal(t, tt.req.Query, result.Query)
-			assert.Equal(t, tt.expectItems, len(result.Items))
-
-			if tt.expectError != "" {
-				assert.Equal(t, tt.expectError, result.Error)
-			} else {
-				assert.Empty(t, result.Error)
-			}
-
-			// Duration should be set
+			assert.Equal(t, tt.expectError, result.Error)
+			assert.Equal(t, 0, len(result.Items))
 			assert.GreaterOrEqual(t, result.Duration, int64(0))
 		})
 	}
@@ -195,21 +115,374 @@ func TestHandler_Search_SourcePreserved(t *testing.T) {
 	}
 }
 
-func TestHandler_Search_MaxResultsFromConfig(t *testing.T) {
-	cfg := &types.DBConfig{
-		Models:     []string{"product"},
-		MaxResults: 50,
-	}
-	h := NewHandler("builtin", cfg)
+func TestHandler_BuildModelSchema(t *testing.T) {
+	h := NewHandler("builtin", nil)
 
-	req := &types.Request{
-		Type:   types.SearchTypeDB,
-		Query:  "test",
-		Models: []string{"product"},
-		// No limit in request, should use config's MaxResults
+	// Create a mock model for testing
+	mod := &model.Model{
+		MetaData: model.MetaData{
+			Table: model.Table{
+				Name: "test_products",
+			},
+		},
+		Columns: map[string]*model.Column{
+			"id": {
+				Name:  "id",
+				Type:  "ID",
+				Label: "ID",
+			},
+			"name": {
+				Name:        "name",
+				Type:        "string",
+				Label:       "Name",
+				Description: "Product name",
+			},
+			"price": {
+				Name:  "price",
+				Type:  "decimal",
+				Label: "Price",
+			},
+		},
+	}
+
+	schema := h.buildModelSchema(mod)
+
+	assert.NotNil(t, schema)
+	assert.Equal(t, "test_products", schema["name"])
+
+	columns, ok := schema["columns"].([]map[string]interface{})
+	assert.True(t, ok)
+	assert.Len(t, columns, 3)
+
+	// Verify columns have required fields
+	for _, col := range columns {
+		assert.NotEmpty(t, col["name"])
+		assert.NotEmpty(t, col["type"])
 	}
-	result, err := h.Search(req)
-	assert.NoError(t, err)
-	assert.NotNil(t, result)
-	// Skeleton doesn't actually use maxResults yet, but the test ensures the handler runs
+}
+
+func TestHandler_BuildModelSchema_MultipleModels(t *testing.T) {
+	h := NewHandler("builtin", nil)
+
+	// Create mock models for testing joins
+	productMod := &model.Model{
+		MetaData: model.MetaData{
+			Table: model.Table{Name: "products"},
+		},
+		Columns: map[string]*model.Column{
+			"id":          {Name: "id", Type: "ID"},
+			"name":        {Name: "name", Type: "string"},
+			"category_id": {Name: "category_id", Type: "integer"},
+		},
+	}
+
+	categoryMod := &model.Model{
+		MetaData: model.MetaData{
+			Table: model.Table{Name: "categories"},
+		},
+		Columns: map[string]*model.Column{
+			"id":   {Name: "id", Type: "ID"},
+			"name": {Name: "name", Type: "string"},
+		},
+	}
+
+	productSchema := h.buildModelSchema(productMod)
+	categorySchema := h.buildModelSchema(categoryMod)
+
+	assert.Equal(t, "products", productSchema["name"])
+	assert.Equal(t, "categories", categorySchema["name"])
+
+	// Verify both schemas can be combined into an array
+	schemas := []map[string]interface{}{productSchema, categorySchema}
+	assert.Len(t, schemas, 2)
+}
+
+func TestHandler_ExtractTitle(t *testing.T) {
+	h := NewHandler("builtin", nil)
+	mod := &model.Model{}
+
+	tests := []struct {
+		name     string
+		record   map[string]interface{}
+		expected string
+	}{
+		{
+			name:     "title field",
+			record:   map[string]interface{}{"title": "Test Title", "id": 1},
+			expected: "Test Title",
+		},
+		{
+			name:     "name field",
+			record:   map[string]interface{}{"name": "Test Name", "id": 1},
+			expected: "Test Name",
+		},
+		{
+			name:     "subject field",
+			record:   map[string]interface{}{"subject": "Test Subject", "id": 1},
+			expected: "Test Subject",
+		},
+		{
+			name:     "label field",
+			record:   map[string]interface{}{"label": "Test Label", "id": 1},
+			expected: "Test Label",
+		},
+		{
+			name:     "no title field",
+			record:   map[string]interface{}{"id": 1, "price": 100},
+			expected: "",
+		},
+		{
+			name:     "empty title",
+			record:   map[string]interface{}{"title": "", "name": "Fallback"},
+			expected: "Fallback",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			title := h.extractTitle(tt.record, mod)
+			assert.Equal(t, tt.expected, title)
+		})
+	}
+}
+
+func TestHandler_ExtractContent(t *testing.T) {
+	h := NewHandler("builtin", nil)
+	mod := &model.Model{}
+
+	tests := []struct {
+		name        string
+		record      map[string]interface{}
+		expectEmpty bool
+	}{
+		{
+			name:        "content field",
+			record:      map[string]interface{}{"content": "Test Content"},
+			expectEmpty: false,
+		},
+		{
+			name:        "description field",
+			record:      map[string]interface{}{"description": "Test Description"},
+			expectEmpty: false,
+		},
+		{
+			name:        "summary field",
+			record:      map[string]interface{}{"summary": "Test Summary"},
+			expectEmpty: false,
+		},
+		{
+			name:        "fallback to JSON",
+			record:      map[string]interface{}{"id": 1, "price": 100},
+			expectEmpty: false, // Should return JSON representation
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			content := h.extractContent(tt.record, mod)
+			if tt.expectEmpty {
+				assert.Empty(t, content)
+			} else {
+				assert.NotEmpty(t, content)
+			}
+		})
+	}
+}
+
+func TestHandler_ConvertToResultItems(t *testing.T) {
+	h := NewHandler("builtin", nil)
+	mod := &model.Model{
+		PrimaryKey: "id",
+	}
+
+	records := []map[string]interface{}{
+		{
+			"id":          1,
+			"name":        "Product 1",
+			"description": "Description 1",
+			"price":       99.99,
+		},
+		{
+			"id":      2,
+			"title":   "Product 2",
+			"content": "Content 2",
+		},
+	}
+
+	items := h.convertToResultItems(records, "product", mod, types.SourceAuto)
+
+	assert.Len(t, items, 2)
+
+	// First item
+	assert.Equal(t, types.SearchTypeDB, items[0].Type)
+	assert.Equal(t, types.SourceAuto, items[0].Source)
+	assert.Equal(t, "product", items[0].Model)
+	assert.Equal(t, 1, items[0].RecordID)
+	assert.Equal(t, "Product 1", items[0].Title)
+	assert.Equal(t, "Description 1", items[0].Content)
+	assert.NotNil(t, items[0].Data)
+
+	// Second item
+	assert.Equal(t, 2, items[1].RecordID)
+	assert.Equal(t, "Product 2", items[1].Title)
+	assert.Equal(t, "Content 2", items[1].Content)
+}
+
+func TestHandler_ConvertToResultItems_NilModel(t *testing.T) {
+	h := NewHandler("builtin", nil)
+
+	records := []map[string]interface{}{
+		{"id": 1, "name": "Test"},
+	}
+
+	// Should use default primary key "id" when model is nil
+	items := h.convertToResultItems(records, "test", nil, types.SourceHook)
+
+	assert.Len(t, items, 1)
+	assert.Equal(t, 1, items[0].RecordID)
+	assert.Equal(t, "Test", items[0].Title)
+}
+
+func TestHandler_Search_ScenarioTypes(t *testing.T) {
+	// Test that all scenario types are valid
+	scenarios := []types.ScenarioType{
+		types.ScenarioFilter,
+		types.ScenarioAggregation,
+		types.ScenarioJoin,
+		types.ScenarioComplex,
+	}
+
+	for _, scenario := range scenarios {
+		t.Run(string(scenario), func(t *testing.T) {
+			h := NewHandler("builtin", &types.DBConfig{Models: []string{"product"}})
+			req := &types.Request{
+				Type:     types.SearchTypeDB,
+				Query:    "test query",
+				Source:   types.SourceAuto,
+				Models:   []string{"product"},
+				Scenario: scenario,
+			}
+
+			// Without context, should return error (but scenario should be preserved in request)
+			result, err := h.Search(req)
+			assert.NoError(t, err)
+			assert.NotNil(t, result)
+			// Verify request scenario is set correctly
+			assert.Equal(t, scenario, req.Scenario)
+		})
+	}
+}
+
+func TestScenarioTypeConstants(t *testing.T) {
+	// Verify scenario type constants match expected values
+	assert.Equal(t, types.ScenarioType("filter"), types.ScenarioFilter)
+	assert.Equal(t, types.ScenarioType("aggregation"), types.ScenarioAggregation)
+	assert.Equal(t, types.ScenarioType("join"), types.ScenarioJoin)
+	assert.Equal(t, types.ScenarioType("complex"), types.ScenarioComplex)
+}
+
+func TestHandler_MergeDSLConditions(t *testing.T) {
+	h := NewHandler("builtin", nil)
+
+	t.Run("merge wheres", func(t *testing.T) {
+		dsl := &gou.QueryDSL{
+			From: &gou.Table{Name: "users"},
+			Wheres: []gou.Where{
+				{Condition: gou.Condition{Field: &gou.Expression{Field: "status"}, Value: "active", OP: "="}},
+			},
+		}
+		req := &types.Request{
+			Wheres: []gou.Where{
+				{Condition: gou.Condition{Field: &gou.Expression{Field: "tenant_id"}, Value: 1, OP: "="}},
+			},
+		}
+
+		h.mergeDSLConditions(dsl, req)
+
+		// Preset wheres should be prepended
+		assert.Len(t, dsl.Wheres, 2)
+		assert.Equal(t, "tenant_id", dsl.Wheres[0].Field.Field)
+		assert.Equal(t, "status", dsl.Wheres[1].Field.Field)
+	})
+
+	t.Run("merge orders", func(t *testing.T) {
+		dsl := &gou.QueryDSL{
+			From: &gou.Table{Name: "products"},
+			Orders: gou.Orders{
+				{Field: &gou.Expression{Field: "name"}, Sort: "asc"},
+			},
+		}
+		req := &types.Request{
+			Orders: gou.Orders{
+				{Field: &gou.Expression{Field: "created_at"}, Sort: "desc"},
+			},
+		}
+
+		h.mergeDSLConditions(dsl, req)
+
+		// Preset orders should be prepended
+		assert.Len(t, dsl.Orders, 2)
+		assert.Equal(t, "created_at", dsl.Orders[0].Field.Field)
+		assert.Equal(t, "name", dsl.Orders[1].Field.Field)
+	})
+
+	t.Run("merge select fields", func(t *testing.T) {
+		dsl := &gou.QueryDSL{
+			From: &gou.Table{Name: "orders"},
+			Select: []gou.Expression{
+				{Field: "amount"},
+			},
+		}
+		req := &types.Request{
+			Select: []string{"id", "status"},
+		}
+
+		h.mergeDSLConditions(dsl, req)
+
+		// Preset select should be prepended
+		assert.Len(t, dsl.Select, 3)
+		assert.Equal(t, "id", dsl.Select[0].Field)
+		assert.Equal(t, "status", dsl.Select[1].Field)
+		assert.Equal(t, "amount", dsl.Select[2].Field)
+	})
+
+	t.Run("set limit from request", func(t *testing.T) {
+		dsl := &gou.QueryDSL{
+			From:  &gou.Table{Name: "users"},
+			Limit: 0,
+		}
+		req := &types.Request{
+			Limit: 50,
+		}
+
+		h.mergeDSLConditions(dsl, req)
+
+		assert.Equal(t, 50, dsl.Limit)
+	})
+
+	t.Run("preserve dsl limit if set", func(t *testing.T) {
+		dsl := &gou.QueryDSL{
+			From:  &gou.Table{Name: "users"},
+			Limit: 10,
+		}
+		req := &types.Request{
+			Limit: 50,
+		}
+
+		h.mergeDSLConditions(dsl, req)
+
+		// DSL limit should be preserved
+		assert.Equal(t, 10, dsl.Limit)
+	})
+
+	t.Run("nil dsl", func(t *testing.T) {
+		req := &types.Request{
+			Wheres: []gou.Where{
+				{Condition: gou.Condition{Field: &gou.Expression{Field: "id"}, Value: 1}},
+			},
+		}
+
+		// Should not panic
+		h.mergeDSLConditions(nil, req)
+	})
 }
diff --git a/agent/search/interfaces/handler.go b/agent/search/interfaces/handler.go
index 0820f10c..fc44a266 100644
--- a/agent/search/interfaces/handler.go
+++ b/agent/search/interfaces/handler.go
@@ -1,6 +1,7 @@
 package interfaces
 
 import (
+	"github.com/yaoapp/yao/agent/context"
 	"github.com/yaoapp/yao/agent/search/types"
 )
 
@@ -12,3 +13,12 @@ type Handler interface {
 	// Search executes the search and returns results
 	Search(req *types.Request) (*types.Result, error)
 }
+
+// ContextHandler extends Handler with context support
+// Handlers that need context (e.g., DB handler for QueryDSL generation) should implement this
+type ContextHandler interface {
+	Handler
+
+	// SearchWithContext executes the search with context and returns results
+	SearchWithContext(ctx *context.Context, req *types.Request) (*types.Result, error)
+}
diff --git a/agent/search/jsapi_db_test.go b/agent/search/jsapi_db_test.go
new file mode 100644
index 00000000..5a8160a1
--- /dev/null
+++ b/agent/search/jsapi_db_test.go
@@ -0,0 +1,190 @@
+package search_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/yaoapp/gou/model"
+	"github.com/yaoapp/yao/agent/context"
+	"github.com/yaoapp/yao/agent/search"
+	"github.com/yaoapp/yao/agent/search/types"
+	"github.com/yaoapp/yao/agent/testutils"
+	oauthTypes "github.com/yaoapp/yao/openapi/oauth/types"
+)
+
+// ============================================================================
+// DB Search JSAPI Integration Tests
+// ============================================================================
+
+func TestJSAPI_DB_Integration(t *testing.T) {
+	// Skip if running short tests
+	if testing.Short() {
+		t.Skip("Skipping integration test")
+	}
+
+	// Initialize test environment
+	testutils.Prepare(t)
+	defer testutils.Clean(t)
+
+	// Create test context
+	ctx := newJSAPITestContext(t)
+
+	// Verify __yao.role model is loaded
+	mod := model.Select("__yao.role")
+	require.NotNil(t, mod, "__yao.role model should be loaded")
+
+	// Ensure test data exists
+	ensureJSAPITestRole(t, mod)
+
+	t.Run("db_search_with_context", func(t *testing.T) {
+		api := search.NewJSAPI(ctx, &types.Config{
+			DB: &types.DBConfig{
+				Models:     []string{"__yao.role"},
+				MaxResults: 10,
+			},
+		}, &search.Uses{QueryDSL: "builtin"})
+
+		result := api.DB("查询所有角色", map[string]interface{}{
+			"models": []interface{}{"__yao.role"},
+			"limit":  float64(10),
+		})
+
+		require.NotNil(t, result)
+		r, ok := result.(*types.Result)
+		require.True(t, ok)
+
+		assert.Equal(t, types.SearchTypeDB, r.Type)
+		assert.Equal(t, "查询所有角色", r.Query)
+		assert.Equal(t, types.SourceHook, r.Source)
+
+		if r.Error != "" {
+			t.Logf("Search error: %s", r.Error)
+		}
+		assert.Empty(t, r.Error, "Should not have error")
+		assert.Greater(t, len(r.Items), 0, "Should have results")
+	})
+
+	t.Run("db_search_with_scenario", func(t *testing.T) {
+		api := search.NewJSAPI(ctx, &types.Config{
+			DB: &types.DBConfig{
+				Models:     []string{"__yao.role"},
+				MaxResults: 5,
+			},
+		}, &search.Uses{QueryDSL: "builtin"})
+
+		result := api.DB("查询系统角色", map[string]interface{}{
+			"models":   []interface{}{"__yao.role"},
+			"scenario": "filter",
+			"limit":    float64(5),
+		})
+
+		require.NotNil(t, result)
+		r, ok := result.(*types.Result)
+		require.True(t, ok)
+
+		assert.Equal(t, types.SearchTypeDB, r.Type)
+		assert.LessOrEqual(t, len(r.Items), 5, "Should respect limit")
+	})
+
+	t.Run("db_search_with_select_fields", func(t *testing.T) {
+		api := search.NewJSAPI(ctx, &types.Config{
+			DB: &types.DBConfig{
+				Models:     []string{"__yao.role"},
+				MaxResults: 10,
+			},
+		}, &search.Uses{QueryDSL: "builtin"})
+
+		result := api.DB("查询角色名称", map[string]interface{}{
+			"models": []interface{}{"__yao.role"},
+			"select": []interface{}{"id", "name", "description"},
+			"limit":  float64(10),
+		})
+
+		require.NotNil(t, result)
+		r, ok := result.(*types.Result)
+		require.True(t, ok)
+
+		assert.Equal(t, types.SearchTypeDB, r.Type)
+		if r.Error == "" && len(r.Items) > 0 {
+			// Verify items have data
+			for _, item := range r.Items {
+				assert.NotNil(t, item.Data)
+				assert.Equal(t, "__yao.role", item.Model)
+			}
+		}
+	})
+
+	t.Run("db_search_all_with_multiple_types", func(t *testing.T) {
+		api := search.NewJSAPI(ctx, &types.Config{
+			KB: &types.KBConfig{Collections: []string{"docs"}},
+			DB: &types.DBConfig{
+				Models:     []string{"__yao.role"},
+				MaxResults: 10,
+			},
+		}, &search.Uses{QueryDSL: "builtin"})
+
+		requests := []interface{}{
+			map[string]interface{}{
+				"type":   "db",
+				"query":  "查询角色",
+				"models": []interface{}{"__yao.role"},
+				"limit":  float64(5),
+			},
+			map[string]interface{}{
+				"type":        "kb",
+				"query":       "知识库查询",
+				"collections": []interface{}{"docs"},
+				"limit":       float64(5),
+			},
+		}
+
+		results := api.All(requests)
+		require.Len(t, results, 2)
+
+		// DB result
+		r0, ok := results[0].(*types.Result)
+		require.True(t, ok)
+		assert.Equal(t, types.SearchTypeDB, r0.Type)
+
+		// KB result
+		r1, ok := results[1].(*types.Result)
+		require.True(t, ok)
+		assert.Equal(t, types.SearchTypeKB, r1.Type)
+	})
+}
+
+// newJSAPITestContext creates a test context for JSAPI tests
+func newJSAPITestContext(t *testing.T) *context.Context {
+	t.Helper()
+	authorized := &oauthTypes.AuthorizedInfo{
+		UserID: "test-user-jsapi",
+	}
+	chatID := "test-chat-jsapi-db"
+	ctx := context.New(t.Context(), authorized, chatID)
+	return ctx
+}
+
+// ensureJSAPITestRole ensures there's at least one role in the database
+func ensureJSAPITestRole(t *testing.T, mod *model.Model) {
+	t.Helper()
+
+	// Try to find existing roles
+	rows, err := mod.Get(model.QueryParam{Limit: 1})
+	if err == nil && len(rows) > 0 {
+		return
+	}
+
+	// Create a test role
+	_, err = mod.Create(map[string]interface{}{
+		"role_id":     "jsapi_test_role",
+		"name":        "JSAPI Test Role",
+		"description": "A test role for JSAPI unit testing",
+		"is_active":   true,
+		"is_system":   false,
+		"level":       1,
+	})
+	if err != nil {
+		t.Logf("Note: Could not create test role: %v", err)
+	}
+}
diff --git a/agent/search/nlp/querydsl/agent.go b/agent/search/nlp/querydsl/agent.go
index 7142d9a5..901c41e0 100644
--- a/agent/search/nlp/querydsl/agent.go
+++ b/agent/search/nlp/querydsl/agent.go
@@ -45,15 +45,14 @@ func (p *AgentProvider) Generate(ctx *agentContext.Context, input *Input) (*Resu
 	var lastLintErrors string
 
 	for attempt := 1; attempt <= MaxRetries; attempt++ {
-		// Build the request message
-		requestData := p.buildRequestData(input, attempt, lastLintErrors)
-		requestJSON, _ := json.Marshal(requestData)
+		// Build the request message in the format expected by querydsl agent
+		requestMessage := p.buildRequestMessage(input, attempt, lastLintErrors)
 
 		// Create message for the agent
 		messages := []agentContext.Message{
 			{
 				Role:    "user",
-				Content: string(requestJSON),
+				Content: requestMessage,
 			},
 		}
 
@@ -103,38 +102,36 @@ func (p *AgentProvider) Generate(ctx *agentContext.Context, input *Input) (*Resu
 	return nil, fmt.Errorf("QueryDSL generation failed after %d attempts: %w", MaxRetries, lastError)
 }
 
-// buildRequestData constructs the request data for the agent
-func (p *AgentProvider) buildRequestData(input *Input, attempt int, lastLintErrors string) map[string]interface{} {
-	requestData := map[string]interface{}{
-		"query":  input.Query,
-		"models": input.ModelIDs,
-		"limit":  input.Limit,
+// buildRequestMessage constructs the request message for the agent
+// Format follows the querydsl agent prompts.yml:
+// "用户查询\nSchema:\n{schema JSON}"
+func (p *AgentProvider) buildRequestMessage(input *Input, attempt int, lastLintErrors string) string {
+	// Build schema from extra params if provided
+	var schemaJSON string
+	if input.ExtraParams != nil {
+		if schema, ok := input.ExtraParams["schema"]; ok {
+			schemaBytes, _ := json.Marshal(schema)
+			schemaJSON = string(schemaBytes)
+		}
 	}
 
-	// Add optional fields
-	if len(input.Wheres) > 0 {
-		requestData["wheres"] = input.Wheres
+	// Build message in the expected format
+	message := input.Query
+	if schemaJSON != "" {
+		message = fmt.Sprintf("%s\nSchema:\n%s", input.Query, schemaJSON)
 	}
-	if len(input.Orders) > 0 {
-		requestData["orders"] = input.Orders
-	}
-	if len(input.AllowedFields) > 0 {
-		requestData["allowed_fields"] = input.AllowedFields
-	}
-	if len(input.ExtraParams) > 0 {
-		requestData["extra"] = input.ExtraParams
+
+	// Add scenario hint if specified (filter, aggregation, join, complex)
+	if input.Scenario != "" {
+		message = fmt.Sprintf("%s\nScenario: %s", message, input.Scenario)
 	}
 
 	// Add retry context if this is a retry attempt
 	if attempt > 1 && lastLintErrors != "" {
-		requestData["retry"] = map[string]interface{}{
-			"attempt":      attempt,
-			"lint_errors":  lastLintErrors,
-			"instructions": "The previous QueryDSL was invalid. Please fix the errors and regenerate.",
-		}
+		message = fmt.Sprintf("%s\n\nPrevious attempt failed with errors:\n%s\n\nPlease fix the errors and regenerate.", message, lastLintErrors)
 	}
 
-	return requestData
+	return message
 }
 
 // validateDSL validates the generated QueryDSL using the linter
@@ -151,14 +148,25 @@ func (p *AgentProvider) validateDSL(dsl *gou.QueryDSL) *linter.LintResult {
 }
 
 // parseResult extracts QueryDSL from the agent's response
-// The agent should return data in NextHookResponse format: { data: { dsl: {...}, explain: "..." } }
-// The Stream() response wraps this in: { next: { data: { dsl: {...} } } }
+// The querydsl agent returns QueryDSL JSON directly (not wrapped in {dsl: ...})
+// Or returns error JSON: {"error": "code", "message": "..."}
+// Stream() returns *context.Response with QueryDSL in "next" field
 func (p *AgentProvider) parseResult(result interface{}) (*Result, error) {
 	if result == nil {
 		return &Result{}, nil
 	}
 
-	// Try to convert to map first (most common case)
+	// Handle *context.Response directly (most common case from Stream())
+	if resp, ok := result.(*agentContext.Response); ok {
+		genResult := &Result{}
+		if resp.Next != nil {
+			// Next contains the QueryDSL from hook
+			genResult.DSL = p.extractDSL(resp.Next)
+		}
+		return genResult, nil
+	}
+
+	// Try to convert to map first
 	var data map[string]interface{}
 
 	switch v := result.(type) {
@@ -180,21 +188,79 @@ func (p *AgentProvider) parseResult(result interface{}) (*Result, error) {
 		}
 	}
 
-	// Check for "next" field (custom hook data from NextHookResponse)
-	// Stream() returns: { next: { data: { dsl: {...} } } }
-	if next, hasNext := data["next"]; hasNext && next != nil {
-		if nextMap, ok := next.(map[string]interface{}); ok {
-			data = nextMap
-		} else if nextStr, ok := next.(string); ok {
-			if err := json.Unmarshal([]byte(nextStr), &data); err != nil {
-				return &Result{}, nil
+	genResult := &Result{}
+
+	// Check for Stream() wrapper: { content: "...", next: {...} }
+	// The actual response is in "content" field as a string
+	if content, hasContent := data["content"]; hasContent && content != nil {
+		if contentStr, ok := content.(string); ok && contentStr != "" {
+			// Parse the content string as JSON
+			var contentData map[string]interface{}
+			if err := json.Unmarshal([]byte(contentStr), &contentData); err == nil {
+				data = contentData
 			}
 		}
 	}
 
-	// Extract QueryDSL from data
-	// Try common field names: "dsl", "data", "data.dsl"
-	genResult := &Result{}
+	// Check for error response: {"error": "code", "message": "..."}
+	if errCode, hasError := data["error"]; hasError {
+		errMsg := ""
+		if msg, ok := data["message"].(string); ok {
+			errMsg = msg
+		}
+		return nil, fmt.Errorf("QueryDSL generation error [%v]: %s", errCode, errMsg)
+	}
+
+	// Check if this is a direct QueryDSL (has "from" or "select" field)
+	// The querydsl agent returns QueryDSL directly, e.g., {"select": [...], "from": "table", ...}
+	if _, hasFrom := data["from"]; hasFrom {
+		genResult.DSL = p.extractDSL(data)
+		return genResult, nil
+	}
+	if _, hasSelect := data["select"]; hasSelect {
+		genResult.DSL = p.extractDSL(data)
+		return genResult, nil
+	}
+
+	// Fallback: check for wrapped formats
+	// Check for "next" field (custom hook data from NextHookResponse)
+	if next, hasNext := data["next"]; hasNext && next != nil {
+		if nextMap, ok := next.(map[string]interface{}); ok {
+			data = nextMap
+		} else if nextStr, ok := next.(string); ok {
+			if err := json.Unmarshal([]byte(nextStr), &data); err == nil {
+				// Check if parsed data is a QueryDSL
+				if _, hasFrom := data["from"]; hasFrom {
+					genResult.DSL = p.extractDSL(data)
+					return genResult, nil
+				}
+			}
+		}
+	}
+
+	// Check for "dsl" field wrapper
+	if dsl, ok := data["dsl"]; ok {
+		genResult.DSL = p.extractDSL(dsl)
+	} else if d, ok := data["data"]; ok {
+		if dm, ok := d.(map[string]interface{}); ok {
+			// Check if data.data is a wrapped DSL: { dsl: {...} }
+			if dsl, ok := dm["dsl"]; ok {
+				genResult.DSL = p.extractDSL(dsl)
+			} else if _, hasFrom := dm["from"]; hasFrom {
+				// data.data is directly a QueryDSL (from __yao.querydsl Next hook)
+				genResult.DSL = p.extractDSL(dm)
+			} else if _, hasSelect := dm["select"]; hasSelect {
+				// data.data is directly a QueryDSL
+				genResult.DSL = p.extractDSL(dm)
+			}
+			if explain, ok := dm["explain"].(string); ok {
+				genResult.Explain = explain
+			}
+			if warnings, ok := dm["warnings"]; ok {
+				genResult.Warnings = p.extractWarnings(warnings)
+			}
+		}
+	}
 
 	// Get explain if present
 	if explain, ok := data["explain"].(string); ok {
@@ -206,23 +272,6 @@ func (p *AgentProvider) parseResult(result interface{}) (*Result, error) {
 		genResult.Warnings = p.extractWarnings(warnings)
 	}
 
-	// Get DSL
-	if dsl, ok := data["dsl"]; ok {
-		genResult.DSL = p.extractDSL(dsl)
-	} else if d, ok := data["data"]; ok {
-		if dm, ok := d.(map[string]interface{}); ok {
-			if dsl, ok := dm["dsl"]; ok {
-				genResult.DSL = p.extractDSL(dsl)
-			}
-			if explain, ok := dm["explain"].(string); ok {
-				genResult.Explain = explain
-			}
-			if warnings, ok := dm["warnings"]; ok {
-				genResult.Warnings = p.extractWarnings(warnings)
-			}
-		}
-	}
-
 	return genResult, nil
 }
 
diff --git a/agent/search/nlp/querydsl/types.go b/agent/search/nlp/querydsl/types.go
index 0c9b6d3b..55693c75 100644
--- a/agent/search/nlp/querydsl/types.go
+++ b/agent/search/nlp/querydsl/types.go
@@ -2,12 +2,14 @@ package querydsl
 
 import (
 	"github.com/yaoapp/gou/query/gou"
+	"github.com/yaoapp/yao/agent/search/types"
 )
 
 // Input contains all information needed to generate QueryDSL
 type Input struct {
 	Query         string                 // Natural language query
 	ModelIDs      []string               // Target model IDs (e.g., ["user", "order", "product"])
+	Scenario      types.ScenarioType     // QueryDSL scenario: "filter", "aggregation", "join", "complex"
 	Wheres        []gou.Where            // Pre-defined filters (optional)
 	Orders        gou.Orders             // Sort orders (optional)
 	AllowedFields []string               // Allowed fields whitelist (optional, for security validation)
diff --git a/agent/search/search.go b/agent/search/search.go
index a8ed1373..a769832f 100644
--- a/agent/search/search.go
+++ b/agent/search/search.go
@@ -60,8 +60,14 @@ func (s *Searcher) Search(ctx *context.Context, req *types.Request) (*types.Resu
 		return &types.Result{Error: "unsupported search type"}, nil
 	}
 
-	// Execute search
-	result, err := handler.Search(req)
+	// Execute search - use context if handler supports it
+	var result *types.Result
+	var err error
+	if ctxHandler, ok := handler.(interfaces.ContextHandler); ok {
+		result, err = ctxHandler.SearchWithContext(ctx, req)
+	} else {
+		result, err = handler.Search(req)
+	}
 	if err != nil {
 		return &types.Result{Error: err.Error()}, nil
 	}
diff --git a/agent/search/types/types.go b/agent/search/types/types.go
index 6d089a64..75ba6712 100644
--- a/agent/search/types/types.go
+++ b/agent/search/types/types.go
@@ -14,6 +14,17 @@ const (
 	SearchTypeDB  SearchType = "db"  // Database search (Yao Model/QueryDSL)
 )
 
+// ScenarioType represents the QueryDSL generation scenario
+type ScenarioType string
+
+// ScenarioType constants for QueryDSL generation
+const (
+	ScenarioFilter      ScenarioType = "filter"      // Simple filtering queries
+	ScenarioAggregation ScenarioType = "aggregation" // Aggregation/grouping queries
+	ScenarioJoin        ScenarioType = "join"        // Multi-table join queries
+	ScenarioComplex     ScenarioType = "complex"     // Complex queries combining multiple features
+)
+
 // SourceType represents where the search result came from
 type SourceType string
 
@@ -42,10 +53,11 @@ type Request struct {
 	Graph       bool     `json:"graph,omitempty"`       // Enable graph association
 
 	// Database search specific
-	Models []string    `json:"models,omitempty"` // Model IDs (e.g., "user", "agents.mybot.product")
-	Wheres []gou.Where `json:"wheres,omitempty"` // Pre-defined filters (optional), uses GOU QueryDSL Where
-	Orders gou.Orders  `json:"orders,omitempty"` // Sort orders (optional), uses GOU QueryDSL Orders
-	Select []string    `json:"select,omitempty"` // Fields to return (optional)
+	Models   []string     `json:"models,omitempty"`   // Model IDs (e.g., "user", "agents.mybot.product")
+	Scenario ScenarioType `json:"scenario,omitempty"` // QueryDSL scenario: "filter", "aggregation", "join", "complex"
+	Wheres   []gou.Where  `json:"wheres,omitempty"`   // Pre-defined filters (optional), uses GOU QueryDSL Where
+	Orders   gou.Orders   `json:"orders,omitempty"`   // Sort orders (optional), uses GOU QueryDSL Orders
+	Select   []string     `json:"select,omitempty"`   // Fields to return (optional)
 
 	// Reranking
 	Rerank *RerankOptions `json:"rerank,omitempty"`
diff --git a/agent/testutils/testutils.go b/agent/testutils/testutils.go
index 5c79c7a7..ef9d246b 100644
--- a/agent/testutils/testutils.go
+++ b/agent/testutils/testutils.go
@@ -3,9 +3,12 @@ package testutils
 import (
 	"testing"
 
+	_ "github.com/yaoapp/gou/encoding"
+	_ "github.com/yaoapp/gou/text"
 	"github.com/yaoapp/yao/agent"
 	"github.com/yaoapp/yao/config"
 	"github.com/yaoapp/yao/kb"
+	"github.com/yaoapp/yao/query"
 	"github.com/yaoapp/yao/test"
 )
 
@@ -17,8 +20,14 @@ import (
 func Prepare(t *testing.T, opts ...interface{}) {
 	test.Prepare(t, config.Conf, opts...)
 
+	// Load Query Engine (required for DB search)
+	err := query.Load(config.Conf)
+	if err != nil {
+		t.Fatal(err)
+	}
+
 	// Load KB (required for agent KB features)
-	_, err := kb.Load(config.Conf)
+	_, err = kb.Load(config.Conf)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/data/bindata.go b/data/bindata.go
index d29b9983..342eb291 100644
--- a/data/bindata.go
+++ b/data/bindata.go
@@ -340,7 +340,7 @@ func cuiSetupIndexHtml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "cui/setup/index.html", size: 10, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "cui/setup/index.html", size: 10, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -360,7 +360,7 @@ func cuiV09IndexHtml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "cui/v0.9/index.html", size: 13, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "cui/v0.9/index.html", size: 13, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -380,7 +380,7 @@ func cuiV10IndexHtml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "cui/v1.0/index.html", size: 49, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "cui/v1.0/index.html", size: 49, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -400,7 +400,7 @@ func cuiV10Layouts__indexAsyncJs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "cui/v1.0/layouts__index.async.js", size: 71, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "cui/v1.0/layouts__index.async.js", size: 71, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -420,7 +420,7 @@ func cuiV10UmiJs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "cui/v1.0/umi.js", size: 71, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "cui/v1.0/umi.js", size: 71, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -440,7 +440,7 @@ func initEnv() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.env", size: 219, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.env", size: 219, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -460,7 +460,7 @@ func initVscodeSettingsJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/settings.json", size: 4666, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/settings.json", size: 4666, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -480,7 +480,7 @@ func initVscodeTypesRuntimeConsoleDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/console.d.ts", size: 221, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/console.d.ts", size: 221, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -500,7 +500,7 @@ func initVscodeTypesRuntimeExceptionDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/exception.d.ts", size: 738, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/exception.d.ts", size: 738, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -520,7 +520,7 @@ func initVscodeTypesRuntimeFsDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/fs.d.ts", size: 8554, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/fs.d.ts", size: 8554, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -540,7 +540,7 @@ func initVscodeTypesRuntimeGlobalDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/global.d.ts", size: 1759, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/global.d.ts", size: 1759, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -560,7 +560,7 @@ func initVscodeTypesRuntimeHttpDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/http.d.ts", size: 6179, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/http.d.ts", size: 6179, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -580,7 +580,7 @@ func initVscodeTypesRuntimeIoDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/io.d.ts", size: 587, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/io.d.ts", size: 587, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -600,7 +600,7 @@ func initVscodeTypesRuntimeLogDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/log.d.ts", size: 1692, mode: os.FileMode(493), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/log.d.ts", size: 1692, mode: os.FileMode(493), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -620,7 +620,7 @@ func initVscodeTypesRuntimeNeoDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/neo.d.ts", size: 3750, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/neo.d.ts", size: 3750, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -640,7 +640,7 @@ func initVscodeTypesRuntimeProcessFsDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/process/fs.d.ts", size: 11133, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/process/fs.d.ts", size: 11133, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -660,7 +660,7 @@ func initVscodeTypesRuntimeProcessHttpDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/process/http.d.ts", size: 5653, mode: os.FileMode(493), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/process/http.d.ts", size: 5653, mode: os.FileMode(493), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -680,7 +680,7 @@ func initVscodeTypesRuntimeProcessModelDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/process/model.d.ts", size: 6656, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/process/model.d.ts", size: 6656, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -700,7 +700,7 @@ func initVscodeTypesRuntimeProcessDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/process.d.ts", size: 23165, mode: os.FileMode(493), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/process.d.ts", size: 23165, mode: os.FileMode(493), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -720,7 +720,7 @@ func initVscodeTypesRuntimeQueryDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/query.d.ts", size: 6124, mode: os.FileMode(493), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/query.d.ts", size: 6124, mode: os.FileMode(493), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -740,7 +740,7 @@ func initVscodeTypesRuntimeStoreDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/store.d.ts", size: 2251, mode: os.FileMode(493), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/store.d.ts", size: 2251, mode: os.FileMode(493), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -760,7 +760,7 @@ func initVscodeTypesRuntimeSuiDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/sui.d.ts", size: 1713, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/sui.d.ts", size: 1713, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -780,7 +780,7 @@ func initVscodeTypesRuntimeTimeDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime/time.d.ts", size: 711, mode: os.FileMode(493), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime/time.d.ts", size: 711, mode: os.FileMode(493), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -800,7 +800,7 @@ func initVscodeTypesRuntimeDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/runtime.d.ts", size: 424, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/runtime.d.ts", size: 424, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -820,7 +820,7 @@ func initVscodeTypesSuiDTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/.vscode/types/sui.d.ts", size: 8931, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/.vscode/types/sui.d.ts", size: 8931, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -840,7 +840,7 @@ func initAppYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/app.yao", size: 3115, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/app.yao", size: 3115, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -860,7 +860,7 @@ func initDataReadmeMd() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/data/README.md", size: 41, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/data/README.md", size: 41, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -880,7 +880,7 @@ func initDataTemplatesDefault__assetsReadmeMd() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/data/templates/default/__assets/README.md", size: 33, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/data/templates/default/__assets/README.md", size: 33, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -900,7 +900,7 @@ func initDataTemplatesDefault__assetsImagesIconsAppPng() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/data/templates/default/__assets/images/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/data/templates/default/__assets/images/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -920,7 +920,7 @@ func initDataTemplatesDefault__assetsImagesLogosLogo_colorSvg() (*asset, error)
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/data/templates/default/__assets/images/logos/logo_color.svg", size: 2909, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/data/templates/default/__assets/images/logos/logo_color.svg", size: 2909, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -940,7 +940,7 @@ func initDataTemplatesDefault__assetsImagesLogosWordmarkSvg() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/data/templates/default/__assets/images/logos/wordmark.svg", size: 3615, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/data/templates/default/__assets/images/logos/wordmark.svg", size: 3615, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -960,7 +960,7 @@ func initDataTemplatesDefault__dataJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/data/templates/default/__data.json", size: 30, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/data/templates/default/__data.json", size: 30, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -980,7 +980,7 @@ func initDataTemplatesDefault__documentHtml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/data/templates/default/__document.html", size: 492, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/data/templates/default/__document.html", size: 492, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1000,7 +1000,7 @@ func initDataTemplatesDefaultIndexIndexCss() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/data/templates/default/index/index.css", size: 2896, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/data/templates/default/index/index.css", size: 2896, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1020,7 +1020,7 @@ func initDataTemplatesDefaultIndexIndexHtml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/data/templates/default/index/index.html", size: 2361, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/data/templates/default/index/index.html", size: 2361, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1040,7 +1040,7 @@ func initDataTemplatesDefaultIndexIndexJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/data/templates/default/index/index.json", size: 31, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/data/templates/default/index/index.json", size: 31, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1060,7 +1060,7 @@ func initDbReadmeMd() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/db/README.md", size: 84, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/db/README.md", size: 84, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1080,7 +1080,7 @@ func initFlowsMenuFlowYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/flows/menu.flow.yao", size: 813, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/flows/menu.flow.yao", size: 813, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1100,7 +1100,7 @@ func initFormsAccountFormYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/forms/account.form.yao", size: 1194, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/forms/account.form.yao", size: 1194, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1120,7 +1120,7 @@ func initIconsAppIcns() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/icons/app.icns", size: 67465, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/icons/app.icns", size: 67465, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1140,7 +1140,7 @@ func initIconsAppIco() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/icons/app.ico", size: 54993, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/icons/app.ico", size: 54993, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1160,7 +1160,7 @@ func initIconsAppPng() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1180,7 +1180,7 @@ func initLoginsAdminLoginYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/logins/admin.login.yao", size: 302, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/logins/admin.login.yao", size: 302, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1200,7 +1200,7 @@ func initLogsReadmeMd() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/logs/README.md", size: 28, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/logs/README.md", size: 28, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1220,7 +1220,7 @@ func initModelsAdminUserModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/models/admin/user.mod.yao", size: 6416, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/models/admin/user.mod.yao", size: 6416, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1240,7 +1240,7 @@ func initModelsTestsPetModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/models/tests/pet.mod.yao", size: 525, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/models/tests/pet.mod.yao", size: 525, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1260,7 +1260,7 @@ func initNeoNeoYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/neo/neo.yml", size: 724, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/neo/neo.yml", size: 724, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1280,7 +1280,7 @@ func initPublicReadmeMd() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/public/README.md", size: 108, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/public/README.md", size: 108, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1300,7 +1300,7 @@ func initPublicAssetsReadmeMd() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/public/assets/README.md", size: 33, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/public/assets/README.md", size: 33, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1320,7 +1320,7 @@ func initPublicAssetsImagesIconsAppPng() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/public/assets/images/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/public/assets/images/icons/app.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1340,7 +1340,7 @@ func initPublicAssetsImagesLogosLogo_colorSvg() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/public/assets/images/logos/logo_color.svg", size: 2909, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/public/assets/images/logos/logo_color.svg", size: 2909, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1360,7 +1360,7 @@ func initPublicAssetsImagesLogosWordmarkSvg() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/public/assets/images/logos/wordmark.svg", size: 3615, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/public/assets/images/logos/wordmark.svg", size: 3615, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1380,7 +1380,7 @@ func initPublicAssetsLibsuiMinJs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/public/assets/libsui.min.js", size: 12569, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/public/assets/libsui.min.js", size: 12569, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1400,7 +1400,7 @@ func initPublicAssetsLibsuiMinJsMap() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/public/assets/libsui.min.js.map", size: 38553, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/public/assets/libsui.min.js.map", size: 38553, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1420,7 +1420,7 @@ func initPublicIndexCfg() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/public/index.cfg", size: 85, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/public/index.cfg", size: 85, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1440,7 +1440,7 @@ func initPublicIndexSui() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/public/index.sui", size: 5682, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/public/index.sui", size: 5682, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1460,7 +1460,7 @@ func initScriptsAccountTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/scripts/account.ts", size: 2521, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/scripts/account.ts", size: 2521, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1480,7 +1480,7 @@ func initScriptsAiNeoTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/scripts/ai/neo.ts", size: 375, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/scripts/ai/neo.ts", size: 375, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1500,7 +1500,7 @@ func initScriptsTestsTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/scripts/tests.ts", size: 1044, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/scripts/tests.ts", size: 1044, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1520,7 +1520,7 @@ func initScriptsUtilsTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/scripts/utils.ts", size: 1230, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/scripts/utils.ts", size: 1230, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1540,7 +1540,7 @@ func initSuisWebSuiYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/suis/web.sui.yao", size: 675, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/suis/web.sui.yao", size: 675, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1560,7 +1560,7 @@ func initTablesAccountTabYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/tables/account.tab.yao", size: 5597, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/tables/account.tab.yao", size: 5597, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1580,7 +1580,7 @@ func initTsconfigJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "init/tsconfig.json", size: 178, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "init/tsconfig.json", size: 178, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1600,7 +1600,7 @@ func libsuiAgentTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "libsui/agent.ts", size: 15267, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "libsui/agent.ts", size: 15267, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1620,7 +1620,7 @@ func libsuiIndexTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "libsui/index.ts", size: 13049, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "libsui/index.ts", size: 13049, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1640,7 +1640,7 @@ func libsuiUtilsTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "libsui/utils.ts", size: 5959, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "libsui/utils.ts", size: 5959, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1660,7 +1660,7 @@ func libsuiYaoTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "libsui/yao.ts", size: 4338, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "libsui/yao.ts", size: 4338, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1680,7 +1680,7 @@ func publicIndexHtml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "public/index.html", size: 11, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "public/index.html", size: 11, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1700,7 +1700,7 @@ func uiIndexHtml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "ui/index.html", size: 11, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "ui/index.html", size: 11, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1720,7 +1720,7 @@ func yaoAssistantsEntityPackageYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/entity/package.yao", size: 212, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/entity/package.yao", size: 212, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1740,7 +1740,7 @@ func yaoAssistantsEntityPromptsYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/entity/prompts.yml", size: 930, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/entity/prompts.yml", size: 930, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1760,7 +1760,7 @@ func yaoAssistantsKeywordPackageYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/keyword/package.yao", size: 200, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/keyword/package.yao", size: 200, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1780,7 +1780,7 @@ func yaoAssistantsKeywordPromptsYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/keyword/prompts.yml", size: 545, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/keyword/prompts.yml", size: 545, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1800,7 +1800,7 @@ func yaoAssistantsKeywordSrcIndexTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/keyword/src/index.ts", size: 2801, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/keyword/src/index.ts", size: 2801, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1820,7 +1820,7 @@ func yaoAssistantsNeedsearchPackageYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/needsearch/package.yao", size: 207, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/needsearch/package.yao", size: 207, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1840,7 +1840,7 @@ func yaoAssistantsNeedsearchPromptsYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/needsearch/prompts.yml", size: 1572, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/needsearch/prompts.yml", size: 1572, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1860,7 +1860,7 @@ func yaoAssistantsNeedsearchSrcIndexTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/needsearch/src/index.ts", size: 2767, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/needsearch/src/index.ts", size: 2767, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1880,7 +1880,7 @@ func yaoAssistantsPromptPackageYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/prompt/package.yao", size: 186, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/prompt/package.yao", size: 186, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1900,12 +1900,12 @@ func yaoAssistantsPromptPromptsYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/prompt/prompts.yml", size: 621, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/prompt/prompts.yml", size: 621, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
 
-var _yaoAssistantsQuerydslPackageYao = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x34\x8d\x41\x4e\xc4\x30\x0c\x45\xf7\x39\x85\xe5\xf5\x68\x04\xc3\x06\x66\xc9\x0d\x38\x01\x72\x93\x2f\x11\xb5\x4d\x82\x9d\x00\x55\xd5\xbb\xa3\xa4\x9a\xed\x7f\xcf\x7e\xbb\x23\xe2\x24\x2b\xf8\x4e\xfc\xd1\xa0\x1b\xbd\xb7\xb8\x04\x28\x5f\x3a\x0a\x30\xaf\xb1\xd4\x98\x53\x37\x06\xa3\x20\x55\x26\x31\xd0\x77\x83\x46\xd8\xa9\xfa\x9c\x12\x7c\xcd\xda\xc5\x00\x14\x03\xe6\xeb\xcf\xcb\x49\xeb\x56\x46\xe3\x37\xeb\xfc\x78\xde\x0c\xc6\x77\xda\x89\x0d\xa2\xfe\x6b\x1c\x46\x93\x69\x41\x60\x3a\x86\x93\x47\x7b\x68\x8e\x88\x88\x57\xf9\xfb\xac\x79\xc6\xd8\x5e\x9f\xdf\x6e\x97\x73\xaf\x58\x0b\x54\x6a\xd3\xde\x79\xba\xde\x1c\xd1\xe1\x0e\xf7\x1f\x00\x00\xff\xff\x2d\x0e\x79\x35\xe2\x00\x00\x00")
+var _yaoAssistantsQuerydslPackageYao = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x34\x8d\x4d\x8a\xc3\x30\x0c\x46\xf7\x3e\xc5\x87\xd6\x61\x98\xc9\x6a\x9a\x65\x6f\xd0\x13\x14\x25\x16\xd4\xe4\xc7\xa9\x64\xd3\x86\x90\xbb\x17\x3b\x74\xfb\xbd\xa7\xa7\xdd\x01\xb4\xf0\x2c\xd4\x81\x6e\x59\x74\xc3\x35\x87\xc9\x8b\x52\x53\x90\x17\x1b\x34\xac\x29\xc4\xa5\x18\x95\xc1\x73\xe2\x9e\x4d\xf0\xcc\xa2\x41\xec\x54\xd3\xb6\xd6\xca\x2b\xea\xf8\x3d\xcf\x26\x46\x1d\x76\x90\x09\xeb\xf0\x28\xdc\x07\xe3\x7e\x12\x4f\x38\xaa\x13\x6b\xbd\x6a\x0e\x00\x68\xe6\xf7\x3d\xc5\x51\xea\xf6\xff\x77\x69\x9b\x73\x4f\x32\xaf\xa2\x9c\xb2\x96\x3f\xbf\x3f\xad\x03\x0e\x77\xb8\x4f\x00\x00\x00\xff\xff\x87\xb1\xea\xfa\xc4\x00\x00\x00")
 
 func yaoAssistantsQuerydslPackageYaoBytes() ([]byte, error) {
 	return bindataRead(
@@ -1920,7 +1920,7 @@ func yaoAssistantsQuerydslPackageYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/querydsl/package.yao", size: 226, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/querydsl/package.yao", size: 196, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1940,7 +1940,7 @@ func yaoAssistantsQuerydslPromptsAggregationYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/aggregation.yml", size: 6982, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/aggregation.yml", size: 6982, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1960,7 +1960,7 @@ func yaoAssistantsQuerydslPromptsComplexYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/complex.yml", size: 7352, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/complex.yml", size: 7352, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -1980,7 +1980,7 @@ func yaoAssistantsQuerydslPromptsFilterYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/filter.yml", size: 7087, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/filter.yml", size: 7087, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2000,7 +2000,7 @@ func yaoAssistantsQuerydslPromptsJoinYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/join.yml", size: 8167, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/querydsl/prompts/join.yml", size: 8167, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2020,7 +2020,7 @@ func yaoAssistantsQuerydslPromptsYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/querydsl/prompts.yml", size: 5836, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/querydsl/prompts.yml", size: 5836, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2040,7 +2040,7 @@ func yaoAssistantsQuerydslSrcIndexTs() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/querydsl/src/index.ts", size: 1873, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/querydsl/src/index.ts", size: 1873, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2060,7 +2060,7 @@ func yaoAssistantsTitlePackageYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/title/package.yao", size: 178, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/title/package.yao", size: 178, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2080,7 +2080,7 @@ func yaoAssistantsTitlePromptsYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/assistants/title/prompts.yml", size: 958, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/assistants/title/prompts.yml", size: 958, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2100,7 +2100,7 @@ func yaoDataIcons404Png() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/icons/404.png", size: 9342, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/icons/404.png", size: 9342, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2120,7 +2120,7 @@ func yaoDataIconsIconIcns() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/icons/icon.icns", size: 67465, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/icons/icon.icns", size: 67465, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2140,7 +2140,7 @@ func yaoDataIconsIconIco() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/icons/icon.ico", size: 54993, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/icons/icon.ico", size: 54993, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2160,7 +2160,7 @@ func yaoDataIconsIconPng() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/icons/icon.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/icons/icon.png", size: 34558, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2180,7 +2180,7 @@ func yaoDataIndexHtml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/index.html", size: 282, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/index.html", size: 282, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2200,7 +2200,7 @@ func yaoDataKbProvidersChunkingSemanticEnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/chunking/semantic/en.json", size: 5543, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/chunking/semantic/en.json", size: 5543, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2220,7 +2220,7 @@ func yaoDataKbProvidersChunkingSemanticZhCnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/chunking/semantic/zh-cn.json", size: 5446, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/chunking/semantic/zh-cn.json", size: 5446, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2240,7 +2240,7 @@ func yaoDataKbProvidersChunkingStructuredEnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/chunking/structured/en.json", size: 2423, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/chunking/structured/en.json", size: 2423, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2260,7 +2260,7 @@ func yaoDataKbProvidersChunkingStructuredZhCnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/chunking/structured/zh-cn.json", size: 2321, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/chunking/structured/zh-cn.json", size: 2321, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2280,7 +2280,7 @@ func yaoDataKbProvidersConverterMcpEnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/converter/mcp/en.json", size: 4235, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/converter/mcp/en.json", size: 4235, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2300,7 +2300,7 @@ func yaoDataKbProvidersConverterMcpZhCnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/converter/mcp/zh-cn.json", size: 4060, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/converter/mcp/zh-cn.json", size: 4060, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2320,7 +2320,7 @@ func yaoDataKbProvidersConverterOcrEnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/converter/ocr/en.json", size: 6631, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/converter/ocr/en.json", size: 6631, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2340,7 +2340,7 @@ func yaoDataKbProvidersConverterOcrZhCnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/converter/ocr/zh-cn.json", size: 6501, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/converter/ocr/zh-cn.json", size: 6501, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2360,7 +2360,7 @@ func yaoDataKbProvidersConverterOfficeEnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/converter/office/en.json", size: 5476, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/converter/office/en.json", size: 5476, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2380,7 +2380,7 @@ func yaoDataKbProvidersConverterOfficeZhCnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/converter/office/zh-cn.json", size: 5356, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/converter/office/zh-cn.json", size: 5356, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2400,7 +2400,7 @@ func yaoDataKbProvidersConverterUtf8EnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/converter/utf8/en.json", size: 292, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/converter/utf8/en.json", size: 292, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2420,7 +2420,7 @@ func yaoDataKbProvidersConverterUtf8ZhCnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/converter/utf8/zh-cn.json", size: 281, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/converter/utf8/zh-cn.json", size: 281, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2440,7 +2440,7 @@ func yaoDataKbProvidersConverterVideoEnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/converter/video/en.json", size: 6411, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/converter/video/en.json", size: 6411, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2460,7 +2460,7 @@ func yaoDataKbProvidersConverterVideoZhCnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/converter/video/zh-cn.json", size: 6297, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/converter/video/zh-cn.json", size: 6297, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2480,7 +2480,7 @@ func yaoDataKbProvidersConverterVisionEnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/converter/vision/en.json", size: 4085, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/converter/vision/en.json", size: 4085, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2500,7 +2500,7 @@ func yaoDataKbProvidersConverterVisionZhCnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/converter/vision/zh-cn.json", size: 3949, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/converter/vision/zh-cn.json", size: 3949, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2520,7 +2520,7 @@ func yaoDataKbProvidersConverterWhisperEnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/converter/whisper/en.json", size: 4449, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/converter/whisper/en.json", size: 4449, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2540,7 +2540,7 @@ func yaoDataKbProvidersConverterWhisperZhCnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/converter/whisper/zh-cn.json", size: 4312, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/converter/whisper/zh-cn.json", size: 4312, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2560,7 +2560,7 @@ func yaoDataKbProvidersEmbeddingFastembedEnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/embedding/fastembed/en.json", size: 6865, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/embedding/fastembed/en.json", size: 6865, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2580,7 +2580,7 @@ func yaoDataKbProvidersEmbeddingFastembedZhCnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/embedding/fastembed/zh-cn.json", size: 6685, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/embedding/fastembed/zh-cn.json", size: 6685, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2600,7 +2600,7 @@ func yaoDataKbProvidersEmbeddingOpenaiEnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/embedding/openai/en.json", size: 5636, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/embedding/openai/en.json", size: 5636, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2620,7 +2620,7 @@ func yaoDataKbProvidersEmbeddingOpenaiZhCnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/embedding/openai/zh-cn.json", size: 5463, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/embedding/openai/zh-cn.json", size: 5463, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2640,7 +2640,7 @@ func yaoDataKbProvidersExtractionOpenaiEnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/extraction/openai/en.json", size: 9110, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/extraction/openai/en.json", size: 9110, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2660,7 +2660,7 @@ func yaoDataKbProvidersExtractionOpenaiZhCnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/extraction/openai/zh-cn.json", size: 8827, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/extraction/openai/zh-cn.json", size: 8827, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2680,7 +2680,7 @@ func yaoDataKbProvidersFetcherHttpEnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/http/en.json", size: 5885, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/http/en.json", size: 5885, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2700,7 +2700,7 @@ func yaoDataKbProvidersFetcherHttpZhCnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/http/zh-cn.json", size: 5925, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/http/zh-cn.json", size: 5925, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2720,7 +2720,7 @@ func yaoDataKbProvidersFetcherMcpEnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/mcp/en.json", size: 6819, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/mcp/en.json", size: 6819, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2740,7 +2740,7 @@ func yaoDataKbProvidersFetcherMcpZhCnJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/mcp/zh-cn.json", size: 6611, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/data/kb/providers/fetcher/mcp/zh-cn.json", size: 6611, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2760,7 +2760,7 @@ func yaoFieldsModelTransJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/fields/model.trans.json", size: 14938, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/fields/model.trans.json", size: 14938, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2780,7 +2780,7 @@ func yaoLangsEnUsJson() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/langs/en-US.json", size: 66, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/langs/en-US.json", size: 66, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2800,7 +2800,7 @@ func yaoLangsZhCnGlobalYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/langs/zh-cn/global.yml", size: 1762, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/langs/zh-cn/global.yml", size: 1762, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2820,7 +2820,7 @@ func yaoLangsZhCnLoginsAdminLoginYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/langs/zh-cn/logins/admin.login.yml", size: 94, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/langs/zh-cn/logins/admin.login.yml", size: 94, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2840,7 +2840,7 @@ func yaoLangsZhCnLoginsUserLoginYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/langs/zh-cn/logins/user.login.yml", size: 90, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/langs/zh-cn/logins/user.login.yml", size: 90, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2860,7 +2860,7 @@ func yaoLangsZhHkGlobalYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/langs/zh-hk/global.yml", size: 1762, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/langs/zh-hk/global.yml", size: 1762, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2880,7 +2880,7 @@ func yaoLangsZhHkLoginsAdminLoginYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/langs/zh-hk/logins/admin.login.yml", size: 94, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/langs/zh-hk/logins/admin.login.yml", size: 94, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2900,7 +2900,7 @@ func yaoLangsZhHkLoginsUserLoginYml() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/langs/zh-hk/logins/user.login.yml", size: 90, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/langs/zh-hk/logins/user.login.yml", size: 90, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2920,7 +2920,7 @@ func yaoModelsAgentAssistantModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/agent/assistant.mod.yao", size: 6945, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/agent/assistant.mod.yao", size: 6945, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2940,7 +2940,7 @@ func yaoModelsAgentChatModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/agent/chat.mod.yao", size: 3093, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/agent/chat.mod.yao", size: 3093, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2960,7 +2960,7 @@ func yaoModelsAgentMessageModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/agent/message.mod.yao", size: 3712, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/agent/message.mod.yao", size: 3712, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -2980,7 +2980,7 @@ func yaoModelsAgentResumeModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/agent/resume.mod.yao", size: 3896, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/agent/resume.mod.yao", size: 3896, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3000,7 +3000,7 @@ func yaoModelsAgentSearchModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/agent/search.mod.yao", size: 3103, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/agent/search.mod.yao", size: 3103, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3020,7 +3020,7 @@ func yaoModelsAttachmentModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/attachment.mod.yao", size: 4687, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/attachment.mod.yao", size: 4687, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3040,7 +3040,7 @@ func yaoModelsAuditModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/audit.mod.yao", size: 5588, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/audit.mod.yao", size: 5588, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3060,7 +3060,7 @@ func yaoModelsConfigModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/config.mod.yao", size: 1649, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/config.mod.yao", size: 1649, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3080,7 +3080,7 @@ func yaoModelsDslModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/dsl.mod.yao", size: 3826, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/dsl.mod.yao", size: 3826, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3100,7 +3100,7 @@ func yaoModelsInvitationModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/invitation.mod.yao", size: 6693, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/invitation.mod.yao", size: 6693, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3120,7 +3120,7 @@ func yaoModelsJobCategoryModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/job/category.mod.yao", size: 2041, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/job/category.mod.yao", size: 2041, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3140,7 +3140,7 @@ func yaoModelsJobExecutionModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/job/execution.mod.yao", size: 7201, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/job/execution.mod.yao", size: 7201, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3160,7 +3160,7 @@ func yaoModelsJobJobModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/job/job.mod.yao", size: 6330, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/job/job.mod.yao", size: 6330, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3180,7 +3180,7 @@ func yaoModelsJobLogModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/job/log.mod.yao", size: 4711, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/job/log.mod.yao", size: 4711, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3200,7 +3200,7 @@ func yaoModelsKbCollectionModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/kb/collection.mod.yao", size: 5390, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/kb/collection.mod.yao", size: 5390, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3220,7 +3220,7 @@ func yaoModelsKbDocumentModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/kb/document.mod.yao", size: 9906, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/kb/document.mod.yao", size: 9906, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3240,7 +3240,7 @@ func yaoModelsMemberModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/member.mod.yao", size: 14798, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/member.mod.yao", size: 14798, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3260,7 +3260,7 @@ func yaoModelsRoleModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/role.mod.yao", size: 6434, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/role.mod.yao", size: 6434, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3280,7 +3280,7 @@ func yaoModelsTeamModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/team.mod.yao", size: 15823, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/team.mod.yao", size: 15823, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3300,7 +3300,7 @@ func yaoModelsUserOauth_accountModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/user/oauth_account.mod.yao", size: 6928, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/user/oauth_account.mod.yao", size: 6928, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3320,7 +3320,7 @@ func yaoModelsUserTypeModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/user/type.mod.yao", size: 7502, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/user/type.mod.yao", size: 7502, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3340,7 +3340,7 @@ func yaoModelsUserModYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/models/user.mod.yao", size: 12335, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/models/user.mod.yao", size: 12335, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3360,7 +3360,7 @@ func yaoReleaseAppYaz() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/release/app.yaz", size: 181682, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/release/app.yaz", size: 181682, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3380,7 +3380,7 @@ func yaoStoresAgentCacheLruYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/stores/agent/cache.lru.yao", size: 301, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/stores/agent/cache.lru.yao", size: 301, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3400,7 +3400,7 @@ func yaoStoresAgentMemoryBadgerYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/stores/agent/memory.badger.yao", size: 352, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/stores/agent/memory.badger.yao", size: 352, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3420,7 +3420,7 @@ func yaoStoresCacheLruYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/stores/cache.lru.yao", size: 285, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/stores/cache.lru.yao", size: 285, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3440,7 +3440,7 @@ func yaoStoresKbCacheLruYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/stores/kb/cache.lru.yao", size: 304, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/stores/kb/cache.lru.yao", size: 304, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3460,7 +3460,7 @@ func yaoStoresKbStoreBadgerYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/stores/kb/store.badger.yao", size: 349, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/stores/kb/store.badger.yao", size: 349, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3480,7 +3480,7 @@ func yaoStoresOauthCacheLruYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/stores/oauth/cache.lru.yao", size: 301, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/stores/oauth/cache.lru.yao", size: 301, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3500,7 +3500,7 @@ func yaoStoresOauthClientBadgerYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/stores/oauth/client.badger.yao", size: 352, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/stores/oauth/client.badger.yao", size: 352, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3520,7 +3520,7 @@ func yaoStoresOauthStoreBadgerYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/stores/oauth/store.badger.yao", size: 376, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/stores/oauth/store.badger.yao", size: 376, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3540,7 +3540,7 @@ func yaoStoresStoreBadgerYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/stores/store.badger.yao", size: 341, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/stores/store.badger.yao", size: 341, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
@@ -3560,7 +3560,7 @@ func yaoUploadersAttachmentLocalYao() (*asset, error) {
 		return nil, err
 	}
 
-	info := bindataFileInfo{name: "yao/uploaders/attachment.local.yao", size: 1163, mode: os.FileMode(420), modTime: time.Unix(1766027003, 0)}
+	info := bindataFileInfo{name: "yao/uploaders/attachment.local.yao", size: 1163, mode: os.FileMode(420), modTime: time.Unix(1766029760, 0)}
 	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
diff --git a/yao/assistants/querydsl/package.yao b/yao/assistants/querydsl/package.yao
index a486b3e7..3a4229b9 100644
--- a/yao/assistants/querydsl/package.yao
+++ b/yao/assistants/querydsl/package.yao
@@ -1,7 +1,6 @@
 {
   "name": "Query Builder",
   "description": "Build database queries",
-  "connector": "deepseek.v3",
   "type": "worker",
   "uses": { "search": "disabled" },
   "options": {