From 2984b2173173f47f18b6c82fbc86cad4dce4a345 Mon Sep 17 00:00:00 2001 From: wizardchen Date: Sun, 15 Mar 2026 20:55:25 +0800 Subject: [PATCH] refactor: consolidate QA request handling and improve session service interface - Introduced a new `QARequest` type to streamline parameters for KnowledgeQA and AgentQA service calls, replacing multiple parameters with a single structured request. - Updated the `KnowledgeQA` and `AgentQA` methods in the session service interface to accept the new `QARequest` type, enhancing clarity and maintainability. - Refactored the request parsing logic to utilize the new `buildQARequest` method, improving code organization and reducing redundancy. - Implemented a new `resolveAgent` method to simplify custom agent resolution logic, enhancing readability and maintainability. These changes improve the overall structure and usability of the QA request handling, facilitating easier updates and better code organization. --- internal/application/service/session.go | 505 ++++++++++++------------ internal/handler/session/qa.go | 413 +++++++++---------- internal/types/interfaces/session.go | 36 +- internal/types/qa_request.go | 19 + 4 files changed, 461 insertions(+), 512 deletions(-) create mode 100644 internal/types/qa_request.go diff --git a/internal/application/service/session.go b/internal/application/service/session.go index 91408dca..ac4b4ec1 100644 --- a/internal/application/service/session.go +++ b/internal/application/service/session.go @@ -513,18 +513,22 @@ func (s *sessionService) GenerateTitleAsync( // customAgent is optional - if provided, uses custom agent configuration for multiTurnEnabled and historyTurns func (s *sessionService) KnowledgeQA( ctx context.Context, - session *types.Session, - query string, - knowledgeBaseIDs []string, - knowledgeIDs []string, - assistantMessageID string, - summaryModelID string, - webSearchEnabled bool, + req *types.QARequest, eventBus *event.EventBus, - customAgent *types.CustomAgent, - enableMemory bool, - imageURLs []string, imageDescription string, userMessageID string, ) error { + // Unpack request fields for readability + session := req.Session + query := req.Query + knowledgeBaseIDs := req.KnowledgeBaseIDs + knowledgeIDs := req.KnowledgeIDs + assistantMessageID := req.AssistantMessageID + webSearchEnabled := req.WebSearchEnabled + customAgent := req.CustomAgent + enableMemory := req.EnableMemory + imageURLs := req.ImageURLs + imageDescription := req.ImageDescription + userMessageID := req.UserMessageID + logger.Infof( ctx, "Knowledge base question answering parameters, session ID: %s, query: %s, webSearchEnabled: %v, enableMemory: %v", @@ -534,66 +538,16 @@ func (s *sessionService) KnowledgeQA( enableMemory, ) - // Use custom agent's knowledge bases only if request didn't specify any - // When user explicitly @mentions a knowledge base or document, only search those - // If RetrieveKBOnlyWhenMentioned is enabled and no @ mentions, don't use KB at all - hasExplicitMention := len(knowledgeBaseIDs) > 0 || len(knowledgeIDs) > 0 - if customAgent != nil { - logger.Infof(ctx, "KB resolution (quick-answer): hasExplicitMention=%v, RetrieveKBOnlyWhenMentioned=%v, KBSelectionMode=%s", - hasExplicitMention, customAgent.Config.RetrieveKBOnlyWhenMentioned, customAgent.Config.KBSelectionMode) - } - if hasExplicitMention { - logger.Infof(ctx, "Using request-specified targets (ignoring agent config): kbs=%v, docs=%v", knowledgeBaseIDs, knowledgeIDs) - } else if customAgent != nil && customAgent.Config.RetrieveKBOnlyWhenMentioned { - // User didn't mention any KB/file, and the setting requires explicit mention - knowledgeBaseIDs = nil - knowledgeIDs = nil - logger.Infof(ctx, "RetrieveKBOnlyWhenMentioned is enabled and no @ mention found, KB retrieval disabled for this request") - } else { - knowledgeBaseIDs = s.resolveKnowledgeBasesFromAgent(ctx, customAgent, session.TenantID) + // Resolve knowledge bases using shared helper + knowledgeBaseIDs, knowledgeIDs = s.resolveKnowledgeBases(ctx, req) + + // Resolve chat model ID using shared helper + chatModelID, err := s.resolveChatModelID(ctx, req, knowledgeBaseIDs, knowledgeIDs) + if err != nil { + return err } - // Determine chat model ID priority: - // 1. Request's summaryModelID (explicit override) - // 2. Custom agent's ModelID (agent configuration) - // 3. KB / session / system default model (legacy fallback) - var chatModelID string - if summaryModelID != "" { - if model, err := s.modelService.GetModelByID(ctx, summaryModelID); err == nil && model != nil { - chatModelID = summaryModelID - logger.Infof(ctx, "Using request's summary model override: %s", chatModelID) - } else { - logger.Warnf(ctx, "Request provided invalid summary model ID %s: %v, falling back", summaryModelID, err) - } - } - if chatModelID == "" && customAgent != nil && customAgent.Config.ModelID != "" { - chatModelID = customAgent.Config.ModelID - logger.Infof(ctx, "Using custom agent's model_id: %s", chatModelID) - } - if chatModelID == "" { - var err error - chatModelID, err = s.selectChatModelID(ctx, session, knowledgeBaseIDs, knowledgeIDs) - if err != nil { - return err - } - } - - // Initialize default values from config.yaml - rewritePromptSystem := s.cfg.Conversation.RewritePromptSystem - rewritePromptUser := s.cfg.Conversation.RewritePromptUser - vectorThreshold := s.cfg.Conversation.VectorThreshold - keywordThreshold := s.cfg.Conversation.KeywordThreshold - embeddingTopK := s.cfg.Conversation.EmbeddingTopK - rerankTopK := s.cfg.Conversation.RerankTopK - rerankThreshold := s.cfg.Conversation.RerankThreshold - maxRounds := s.cfg.Conversation.MaxRounds - fallbackStrategy := types.FallbackStrategy(s.cfg.Conversation.FallbackStrategy) - fallbackResponse := s.cfg.Conversation.FallbackResponse - fallbackPrompt := s.cfg.Conversation.FallbackPrompt - enableRewrite := s.cfg.Conversation.EnableRewrite - enableQueryExpansion := s.cfg.Conversation.EnableQueryExpansion - rerankModelID := "" - + // Initialize ChatManage defaults from config.yaml summaryConfig := types.SummaryConfig{ Prompt: s.cfg.Conversation.Summary.Prompt, ContextTemplate: s.cfg.Conversation.Summary.ContextTemplate, @@ -602,108 +556,12 @@ func (s *sessionService) KnowledgeQA( MaxCompletionTokens: s.cfg.Conversation.Summary.MaxCompletionTokens, Thinking: s.cfg.Conversation.Summary.Thinking, } - - // Set default fallback strategy if not set + fallbackStrategy := types.FallbackStrategy(s.cfg.Conversation.FallbackStrategy) if fallbackStrategy == "" { fallbackStrategy = types.FallbackStrategyFixed logger.Infof(ctx, "Fallback strategy not set, using default: %v", fallbackStrategy) } - // Apply custom agent configuration if provided - if customAgent != nil { - // Ensure defaults are set - customAgent.EnsureDefaults() - - // Override system prompt - if customAgent.Config.SystemPrompt != "" { - summaryConfig.Prompt = customAgent.Config.SystemPrompt - logger.Infof(ctx, "Using custom agent's system_prompt") - } - // Override context template - if customAgent.Config.ContextTemplate != "" { - summaryConfig.ContextTemplate = customAgent.Config.ContextTemplate - logger.Infof(ctx, "Using custom agent's context_template") - } - // Override temperature - if customAgent.Config.Temperature > 0 { - summaryConfig.Temperature = customAgent.Config.Temperature - logger.Infof(ctx, "Using custom agent's temperature: %f", customAgent.Config.Temperature) - } - // Override max completion tokens - if customAgent.Config.MaxCompletionTokens > 0 { - summaryConfig.MaxCompletionTokens = customAgent.Config.MaxCompletionTokens - logger.Infof(ctx, "Using custom agent's max_completion_tokens: %d", customAgent.Config.MaxCompletionTokens) - } - // Override thinking mode from agent config - // Agent-level thinking setting takes full control (no global fallback) - summaryConfig.Thinking = customAgent.Config.Thinking - if customAgent.Config.Thinking != nil { - logger.Infof(ctx, "Using custom agent's thinking: %v", *customAgent.Config.Thinking) - } - // Override retrieval strategy settings - if customAgent.Config.EmbeddingTopK > 0 { - embeddingTopK = customAgent.Config.EmbeddingTopK - } - if customAgent.Config.KeywordThreshold > 0 { - keywordThreshold = customAgent.Config.KeywordThreshold - } - if customAgent.Config.VectorThreshold > 0 { - vectorThreshold = customAgent.Config.VectorThreshold - } - if customAgent.Config.RerankTopK > 0 { - rerankTopK = customAgent.Config.RerankTopK - } - if customAgent.Config.RerankThreshold > 0 { - rerankThreshold = customAgent.Config.RerankThreshold - } - if customAgent.Config.RerankModelID != "" { - rerankModelID = customAgent.Config.RerankModelID - } - // Override rewrite settings - enableRewrite = customAgent.Config.EnableRewrite - enableQueryExpansion = customAgent.Config.EnableQueryExpansion - if customAgent.Config.RewritePromptSystem != "" { - rewritePromptSystem = customAgent.Config.RewritePromptSystem - } - if customAgent.Config.RewritePromptUser != "" { - rewritePromptUser = customAgent.Config.RewritePromptUser - } - // Override fallback settings - if customAgent.Config.FallbackStrategy != "" { - fallbackStrategy = types.FallbackStrategy(customAgent.Config.FallbackStrategy) - } - if customAgent.Config.FallbackResponse != "" { - fallbackResponse = customAgent.Config.FallbackResponse - } - if customAgent.Config.FallbackPrompt != "" { - fallbackPrompt = customAgent.Config.FallbackPrompt - } - // Override history turns - if customAgent.Config.HistoryTurns > 0 { - maxRounds = customAgent.Config.HistoryTurns - logger.Infof(ctx, "Using custom agent's history_turns: %d", maxRounds) - } - // Check if multi-turn is disabled - if !customAgent.Config.MultiTurnEnabled { - maxRounds = 0 // Disable history - logger.Infof(ctx, "Multi-turn disabled by custom agent, clearing history") - } - } - - // Extract FAQ strategy settings from custom agent - var faqPriorityEnabled bool - var faqDirectAnswerThreshold float64 - var faqScoreBoost float64 - if customAgent != nil { - faqPriorityEnabled = customAgent.Config.FAQPriorityEnabled - faqDirectAnswerThreshold = customAgent.Config.FAQDirectAnswerThreshold - faqScoreBoost = customAgent.Config.FAQScoreBoost - if faqPriorityEnabled { - logger.Infof(ctx, "FAQ priority enabled: threshold=%.2f, boost=%.2f", - faqDirectAnswerThreshold, faqScoreBoost) - } - } - // Resolve chat model vision capability and VLM model ID for image routing var chatModelSupportsVision bool var vlmModelID string @@ -716,17 +574,8 @@ func (s *sessionService) KnowledgeQA( vlmModelID = customAgent.Config.VLMModelID } - // Retrieval scope: when agent is set, use agent's tenant (own or shared); otherwise session tenant or context - retrievalTenantID := session.TenantID - if customAgent != nil && customAgent.TenantID != 0 { - retrievalTenantID = customAgent.TenantID - logger.Infof(ctx, "Using agent tenant %d for retrieval scope", retrievalTenantID) - } else if v := ctx.Value(types.TenantIDContextKey); v != nil { - if tid, ok := v.(uint64); ok && tid != 0 { - retrievalTenantID = tid - logger.Infof(ctx, "Using effective tenant %d for retrieval from context", retrievalTenantID) - } - } + // Resolve retrieval tenant scope using shared helper + retrievalTenantID := s.resolveRetrievalTenantID(ctx, req) // Build unified search targets (computed once, used throughout pipeline) searchTargets, err := s.buildSearchTargets(ctx, retrievalTenantID, knowledgeBaseIDs, knowledgeIDs) @@ -752,34 +601,29 @@ func (s *sessionService) KnowledgeQA( RewriteQuery: query, SessionID: session.ID, UserID: userID, - MessageID: assistantMessageID, // NEW: For event emission in pipeline - KnowledgeBaseIDs: knowledgeBaseIDs, // Multi-KB support - KnowledgeIDs: knowledgeIDs, // Specific knowledge (file) IDs - SearchTargets: searchTargets, // Pre-computed search targets - VectorThreshold: vectorThreshold, - KeywordThreshold: keywordThreshold, - EmbeddingTopK: embeddingTopK, - RerankModelID: rerankModelID, - RerankTopK: rerankTopK, - RerankThreshold: rerankThreshold, - MaxRounds: maxRounds, + MessageID: assistantMessageID, + KnowledgeBaseIDs: knowledgeBaseIDs, + KnowledgeIDs: knowledgeIDs, + SearchTargets: searchTargets, + VectorThreshold: s.cfg.Conversation.VectorThreshold, + KeywordThreshold: s.cfg.Conversation.KeywordThreshold, + EmbeddingTopK: s.cfg.Conversation.EmbeddingTopK, + RerankTopK: s.cfg.Conversation.RerankTopK, + RerankThreshold: s.cfg.Conversation.RerankThreshold, + MaxRounds: s.cfg.Conversation.MaxRounds, ChatModelID: chatModelID, SummaryConfig: summaryConfig, FallbackStrategy: fallbackStrategy, - FallbackResponse: fallbackResponse, - FallbackPrompt: fallbackPrompt, - EventBus: eventBus.AsEventBusInterface(), // NEW: For pipeline to emit events directly + FallbackResponse: s.cfg.Conversation.FallbackResponse, + FallbackPrompt: s.cfg.Conversation.FallbackPrompt, + EventBus: eventBus.AsEventBusInterface(), WebSearchEnabled: webSearchEnabled, - EnableMemory: enableMemory, // Enable memory feature - TenantID: retrievalTenantID, // Effective tenant for retrieval (shared agent = agent's tenant) - RewritePromptSystem: rewritePromptSystem, - RewritePromptUser: rewritePromptUser, - EnableRewrite: enableRewrite, - EnableQueryExpansion: enableQueryExpansion, - // FAQ Strategy Settings - FAQPriorityEnabled: faqPriorityEnabled, - FAQDirectAnswerThreshold: faqDirectAnswerThreshold, - FAQScoreBoost: faqScoreBoost, + EnableMemory: enableMemory, + TenantID: retrievalTenantID, + RewritePromptSystem: s.cfg.Conversation.RewritePromptSystem, + RewritePromptUser: s.cfg.Conversation.RewritePromptUser, + EnableRewrite: s.cfg.Conversation.EnableRewrite, + EnableQueryExpansion: s.cfg.Conversation.EnableQueryExpansion, // Image support UserMessageID: userMessageID, Images: imageURLs, @@ -788,6 +632,10 @@ func (s *sessionService) KnowledgeQA( ChatModelSupportsVision: chatModelSupportsVision, } + // Apply custom agent overrides (system prompt, temperature, retrieval params, + // rewrite, fallback, FAQ strategy, history turns) + s.applyAgentOverridesToChatManage(ctx, customAgent, chatManage) + // Determine pipeline based on knowledge bases availability and web search setting // If no knowledge bases are selected AND web search is disabled, use pure chat pipeline // Otherwise use rag_stream pipeline (which handles both KB search and web search) @@ -803,8 +651,8 @@ func (s *sessionService) KnowledgeQA( chatManage.UserContent = userContent // Use chat_history_stream if multi-turn is enabled, otherwise use chat_stream - if maxRounds > 0 { - logger.Infof(ctx, "Multi-turn enabled with maxRounds=%d, using chat_history_stream pipeline", maxRounds) + if chatManage.MaxRounds > 0 { + logger.Infof(ctx, "Multi-turn enabled with maxRounds=%d, using chat_history_stream pipeline", chatManage.MaxRounds) pipeline = types.Pipline["chat_history_stream"] } else { logger.Info(ctx, "Multi-turn disabled, using chat_stream pipeline") @@ -1362,17 +1210,19 @@ func (s *sessionService) SearchKnowledge(ctx context.Context, // summaryModelID is optional - if provided, overrides the model from customAgent config func (s *sessionService) AgentQA( ctx context.Context, - session *types.Session, - query string, - assistantMessageID string, - summaryModelID string, + req *types.QARequest, eventBus *event.EventBus, - customAgent *types.CustomAgent, - knowledgeBaseIDs []string, - knowledgeIDs []string, - imageURLs []string, imageDescription string, userMessageID string, - webSearchEnabled bool, ) error { + // Unpack request fields for readability + session := req.Session + query := req.Query + assistantMessageID := req.AssistantMessageID + customAgent := req.CustomAgent + imageURLs := req.ImageURLs + imageDescription := req.ImageDescription + userMessageID := req.UserMessageID + webSearchEnabled := req.WebSearchEnabled + _ = userMessageID // reserved for future use (AgentQA pipeline differs from KnowledgeQA) sessionID := session.ID sessionJSON, err := json.Marshal(session) @@ -1387,11 +1237,8 @@ func (s *sessionService) AgentQA( return errors.New("custom agent configuration is required for agent QA") } - // Use agent's tenant for retrieval and tenant-scoped config (handler has validated access) - agentTenantID := customAgent.TenantID - if agentTenantID == 0 { - agentTenantID = session.TenantID - } + // Resolve retrieval tenant using shared helper + agentTenantID := s.resolveRetrievalTenantID(ctx, req) logger.Infof(ctx, "Start agent-based question answering, session ID: %s, agent tenant ID: %d, query: %s, session: %s", sessionID, agentTenantID, query, string(sessionJSON)) @@ -1435,30 +1282,8 @@ func (s *sessionService) AgentQA( // Configure skills based on CustomAgentConfig s.configureSkillsFromAgent(ctx, agentConfig, customAgent) - // Resolve knowledge bases: request-level @ mentions take priority over agent config - // If RetrieveKBOnlyWhenMentioned is enabled and no @ mentions, don't use KB at all - hasExplicitMention := len(knowledgeBaseIDs) > 0 || len(knowledgeIDs) > 0 - logger.Infof(ctx, "KB resolution: hasExplicitMention=%v, RetrieveKBOnlyWhenMentioned=%v, KBSelectionMode=%s", - hasExplicitMention, agentConfig.RetrieveKBOnlyWhenMentioned, customAgent.Config.KBSelectionMode) - if hasExplicitMention { - // User explicitly specified via @ mention - if len(knowledgeBaseIDs) > 0 { - agentConfig.KnowledgeBases = knowledgeBaseIDs - logger.Infof(ctx, "Using request-specified knowledge bases: %v", knowledgeBaseIDs) - } - if len(knowledgeIDs) > 0 { - agentConfig.KnowledgeIDs = knowledgeIDs - logger.Infof(ctx, "Using request-specified knowledge IDs: %v", knowledgeIDs) - } - } else if agentConfig.RetrieveKBOnlyWhenMentioned { - // User didn't mention any KB/file, and the setting requires explicit mention - agentConfig.KnowledgeBases = nil - agentConfig.KnowledgeIDs = nil - logger.Infof(ctx, "RetrieveKBOnlyWhenMentioned is enabled and no @ mention found, KB retrieval disabled for this request") - } else { - // Use agent's configured knowledge bases based on KBSelectionMode - agentConfig.KnowledgeBases = s.resolveKnowledgeBasesFromAgent(ctx, customAgent, session.TenantID) - } + // Resolve knowledge bases using shared helper + agentConfig.KnowledgeBases, agentConfig.KnowledgeIDs = s.resolveKnowledgeBases(ctx, req) // Use custom agent's allowed tools if specified, otherwise use defaults if len(customAgent.Config.AllowedTools) > 0 { @@ -1504,21 +1329,15 @@ func (s *sessionService) AgentQA( agentConfig.SearchTargets = searchTargets logger.Infof(ctx, "Agent search targets built: %d targets", len(searchTargets)) - // Get summary model: prioritize request's summaryModelID, then custom agent config - // Note: tenantInfo.ConversationConfig is deprecated, all config comes from customAgent now - effectiveModelID := summaryModelID - if effectiveModelID == "" { - effectiveModelID = customAgent.Config.ModelID + // Resolve model ID using shared helper (AgentQA requires a model, so error if not found) + effectiveModelID, err := s.resolveChatModelID(ctx, req, agentConfig.KnowledgeBases, agentConfig.KnowledgeIDs) + if err != nil { + return err } if effectiveModelID == "" { logger.Warnf(ctx, "No summary model configured for custom agent %s", customAgent.ID) return errors.New("summary model (model_id) is not configured in custom agent settings") } - if summaryModelID != "" { - logger.Infof(ctx, "Using request's summary model override: %s", effectiveModelID) - } else { - logger.Infof(ctx, "Using custom agent's model_id: %s", effectiveModelID) - } summaryModel, err := s.modelService.GetChatModel(ctx, effectiveModelID) if err != nil { @@ -1845,3 +1664,189 @@ func (s *sessionService) emitFallbackAnswer(ctx context.Context, chatManage *typ logger.Infof(ctx, "Fallback answer event emitted successfully") } } + +// --------------------------------------------------------------------------- +// Shared QA helpers: KB resolution, model resolution, retrieval tenant +// --------------------------------------------------------------------------- + +// resolveKnowledgeBases resolves the effective knowledge base IDs and knowledge IDs +// for a QA request. Priority: +// 1. Explicit @mentions (request-specified kbIDs / knowledgeIDs) +// 2. RetrieveKBOnlyWhenMentioned → disable KB if no mention +// 3. Agent's configured knowledge bases (via KBSelectionMode) +func (s *sessionService) resolveKnowledgeBases( + ctx context.Context, + req *types.QARequest, +) (kbIDs []string, knowledgeIDs []string) { + kbIDs = req.KnowledgeBaseIDs + knowledgeIDs = req.KnowledgeIDs + customAgent := req.CustomAgent + + hasExplicitMention := len(kbIDs) > 0 || len(knowledgeIDs) > 0 + if customAgent != nil { + logger.Infof(ctx, "KB resolution: hasExplicitMention=%v, RetrieveKBOnlyWhenMentioned=%v, KBSelectionMode=%s", + hasExplicitMention, customAgent.Config.RetrieveKBOnlyWhenMentioned, customAgent.Config.KBSelectionMode) + } + + if hasExplicitMention { + logger.Infof(ctx, "Using request-specified targets: kbs=%v, docs=%v", kbIDs, knowledgeIDs) + } else if customAgent != nil && customAgent.Config.RetrieveKBOnlyWhenMentioned { + kbIDs = nil + knowledgeIDs = nil + logger.Infof(ctx, "RetrieveKBOnlyWhenMentioned is enabled and no @ mention found, KB retrieval disabled for this request") + } else if customAgent != nil { + kbIDs = s.resolveKnowledgeBasesFromAgent(ctx, customAgent, req.Session.TenantID) + } + return kbIDs, knowledgeIDs +} + +// resolveChatModelID resolves the effective chat model ID for a QA request. +// Priority: +// 1. Request's SummaryModelID (explicit override, validated) +// 2. Custom agent's ModelID +// 3. KB / session / system default (via selectChatModelID) +func (s *sessionService) resolveChatModelID( + ctx context.Context, + req *types.QARequest, + knowledgeBaseIDs []string, + knowledgeIDs []string, +) (string, error) { + summaryModelID := req.SummaryModelID + customAgent := req.CustomAgent + session := req.Session + + if summaryModelID != "" { + if model, err := s.modelService.GetModelByID(ctx, summaryModelID); err == nil && model != nil { + logger.Infof(ctx, "Using request's summary model override: %s", summaryModelID) + return summaryModelID, nil + } + logger.Warnf(ctx, "Request provided invalid summary model ID %s, falling back", summaryModelID) + } + if customAgent != nil && customAgent.Config.ModelID != "" { + logger.Infof(ctx, "Using custom agent's model_id: %s", customAgent.Config.ModelID) + return customAgent.Config.ModelID, nil + } + return s.selectChatModelID(ctx, session, knowledgeBaseIDs, knowledgeIDs) +} + +// resolveRetrievalTenantID determines the tenant ID to use for retrieval scope. +// Priority: agent's tenant > context tenant > session tenant. +func (s *sessionService) resolveRetrievalTenantID( + ctx context.Context, + req *types.QARequest, +) uint64 { + session := req.Session + customAgent := req.CustomAgent + + retrievalTenantID := session.TenantID + if customAgent != nil && customAgent.TenantID != 0 { + retrievalTenantID = customAgent.TenantID + logger.Infof(ctx, "Using agent tenant %d for retrieval scope", retrievalTenantID) + } else if v := ctx.Value(types.TenantIDContextKey); v != nil { + if tid, ok := v.(uint64); ok && tid != 0 { + retrievalTenantID = tid + logger.Infof(ctx, "Using effective tenant %d for retrieval from context", retrievalTenantID) + } + } + return retrievalTenantID +} + +// applyAgentOverridesToChatManage applies custom agent configuration overrides +// to a ChatManage object that was initialized with system defaults. +// This covers: system prompt, context template, temperature, max tokens, thinking, +// retrieval thresholds, rewrite settings, fallback settings, FAQ strategy, and history turns. +func (s *sessionService) applyAgentOverridesToChatManage( + ctx context.Context, + customAgent *types.CustomAgent, + cm *types.ChatManage, +) { + if customAgent == nil { + return + } + + // Ensure defaults are set + customAgent.EnsureDefaults() + + // Override summary config fields + if customAgent.Config.SystemPrompt != "" { + cm.SummaryConfig.Prompt = customAgent.Config.SystemPrompt + logger.Infof(ctx, "Using custom agent's system_prompt") + } + if customAgent.Config.ContextTemplate != "" { + cm.SummaryConfig.ContextTemplate = customAgent.Config.ContextTemplate + logger.Infof(ctx, "Using custom agent's context_template") + } + if customAgent.Config.Temperature > 0 { + cm.SummaryConfig.Temperature = customAgent.Config.Temperature + logger.Infof(ctx, "Using custom agent's temperature: %f", customAgent.Config.Temperature) + } + if customAgent.Config.MaxCompletionTokens > 0 { + cm.SummaryConfig.MaxCompletionTokens = customAgent.Config.MaxCompletionTokens + logger.Infof(ctx, "Using custom agent's max_completion_tokens: %d", customAgent.Config.MaxCompletionTokens) + } + // Agent-level thinking setting takes full control (no global fallback) + cm.SummaryConfig.Thinking = customAgent.Config.Thinking + if customAgent.Config.Thinking != nil { + logger.Infof(ctx, "Using custom agent's thinking: %v", *customAgent.Config.Thinking) + } + + // Override retrieval strategy settings + if customAgent.Config.EmbeddingTopK > 0 { + cm.EmbeddingTopK = customAgent.Config.EmbeddingTopK + } + if customAgent.Config.KeywordThreshold > 0 { + cm.KeywordThreshold = customAgent.Config.KeywordThreshold + } + if customAgent.Config.VectorThreshold > 0 { + cm.VectorThreshold = customAgent.Config.VectorThreshold + } + if customAgent.Config.RerankTopK > 0 { + cm.RerankTopK = customAgent.Config.RerankTopK + } + if customAgent.Config.RerankThreshold > 0 { + cm.RerankThreshold = customAgent.Config.RerankThreshold + } + if customAgent.Config.RerankModelID != "" { + cm.RerankModelID = customAgent.Config.RerankModelID + } + + // Override rewrite settings + cm.EnableRewrite = customAgent.Config.EnableRewrite + cm.EnableQueryExpansion = customAgent.Config.EnableQueryExpansion + if customAgent.Config.RewritePromptSystem != "" { + cm.RewritePromptSystem = customAgent.Config.RewritePromptSystem + } + if customAgent.Config.RewritePromptUser != "" { + cm.RewritePromptUser = customAgent.Config.RewritePromptUser + } + + // Override fallback settings + if customAgent.Config.FallbackStrategy != "" { + cm.FallbackStrategy = types.FallbackStrategy(customAgent.Config.FallbackStrategy) + } + if customAgent.Config.FallbackResponse != "" { + cm.FallbackResponse = customAgent.Config.FallbackResponse + } + if customAgent.Config.FallbackPrompt != "" { + cm.FallbackPrompt = customAgent.Config.FallbackPrompt + } + + // Override history turns + if customAgent.Config.HistoryTurns > 0 { + cm.MaxRounds = customAgent.Config.HistoryTurns + logger.Infof(ctx, "Using custom agent's history_turns: %d", cm.MaxRounds) + } + if !customAgent.Config.MultiTurnEnabled { + cm.MaxRounds = 0 + logger.Infof(ctx, "Multi-turn disabled by custom agent, clearing history") + } + + // FAQ strategy settings + cm.FAQPriorityEnabled = customAgent.Config.FAQPriorityEnabled + cm.FAQDirectAnswerThreshold = customAgent.Config.FAQDirectAnswerThreshold + cm.FAQScoreBoost = customAgent.Config.FAQScoreBoost + if cm.FAQPriorityEnabled { + logger.Infof(ctx, "FAQ priority enabled: threshold=%.2f, boost=%.2f", + cm.FAQDirectAnswerThreshold, cm.FAQScoreBoost) + } +} diff --git a/internal/handler/session/qa.go b/internal/handler/session/qa.go index cf8baf3f..e7989cbc 100644 --- a/internal/handler/session/qa.go +++ b/internal/handler/session/qa.go @@ -355,7 +355,7 @@ func (h *Handler) KnowledgeQA(c *gin.Context) { } // Execute normal mode QA, generate title unless disabled - h.executeNormalModeQA(reqCtx, !request.DisableTitle) + h.executeQA(reqCtx, qaModeNormal, !request.DisableTitle) } // AgentQA godoc @@ -390,188 +390,42 @@ func (h *Handler) AgentQA(c *gin.Context) { // Route to appropriate handler based on agent mode if agentModeEnabled { - h.executeAgentModeQA(reqCtx) + h.executeQA(reqCtx, qaModeAgent, true) } else { logger.Infof(reqCtx.ctx, "Agent mode disabled, delegating to normal mode for session: %s", reqCtx.sessionID) - // Knowledge bases should be specified in request or from custom agent - h.executeNormalModeQA(reqCtx, false) + h.executeQA(reqCtx, qaModeNormal, false) } } -// executeNormalModeQA executes the normal (KnowledgeQA) mode -func (h *Handler) executeNormalModeQA(reqCtx *qaRequestContext, generateTitle bool) { +// qaMode determines which QA execution path to use. +type qaMode int + +const ( + qaModeNormal qaMode = iota // KnowledgeQA pipeline (RAG / pure chat) + qaModeAgent // Agent engine with tool calling +) + +// executeQA is the unified execution flow for both KnowledgeQA and AgentQA modes. +// It handles message creation, SSE setup, VLM analysis, service invocation, and error handling. +func (h *Handler) executeQA(reqCtx *qaRequestContext, mode qaMode, generateTitle bool) { ctx := reqCtx.ctx sessionID := reqCtx.sessionID - // Create user message - userMsg, err := h.createUserMessage(ctx, sessionID, reqCtx.query, reqCtx.requestID, reqCtx.mentionedItems, convertImageAttachments(reqCtx.images)) - if err != nil { - reqCtx.c.Error(errors.NewInternalServerError(err.Error())) - return - } - reqCtx.userMessageID = userMsg.ID - - // Create assistant message - if _, err := h.createAssistantMessage(ctx, reqCtx.assistantMessage); err != nil { - reqCtx.c.Error(errors.NewInternalServerError(err.Error())) - return - } - - logger.Infof(ctx, "Using knowledge bases: %v", reqCtx.knowledgeBaseIDs) - - // Setup SSE stream - streamCtx := h.setupSSEStream(reqCtx, generateTitle) - - // Setup completion handler for normal mode - // Note: Thinking content is now embedded in answer stream with tags - // by chat_completion_stream.go, so we don't need separate thinking event handling - var completionHandled bool // Prevent duplicate completion handling - - streamCtx.eventBus.On(event.EventAgentFinalAnswer, func(ctx context.Context, evt event.Event) error { - data, ok := evt.Data.(event.AgentFinalAnswerData) - if !ok { - return nil - } - streamCtx.assistantMessage.Content += data.Content - if data.IsFallback { - streamCtx.assistantMessage.IsFallback = true - } - if data.Done { - // Prevent duplicate completion handling - if completionHandled { - return nil - } - completionHandled = true - - logger.Infof(streamCtx.asyncCtx, "Knowledge QA service completed for session: %s", sessionID) - // Content already contains ... tags from chat_completion_stream.go - // Use session's tenant for message update (asyncCtx may have effectiveTenantID when using shared agent) - updateCtx := context.WithValue(streamCtx.asyncCtx, types.TenantIDContextKey, reqCtx.session.TenantID) - h.completeAssistantMessage(updateCtx, streamCtx.assistantMessage, reqCtx.query) - // Emit EventAgentComplete - this will trigger handleComplete which sends the SSE complete event - // Note: Don't cancel context here, let the SSE handler close naturally after receiving the complete event - streamCtx.eventBus.Emit(streamCtx.asyncCtx, event.Event{ - Type: event.EventAgentComplete, - SessionID: sessionID, - Data: event.AgentCompleteData{FinalAnswer: streamCtx.assistantMessage.Content}, - }) - } - return nil - }) - - // Execute KnowledgeQA asynchronously - go func() { - defer func() { - if r := recover(); r != nil { - buf := make([]byte, 10240) - runtime.Stack(buf, true) - logger.ErrorWithFields(streamCtx.asyncCtx, - errors.NewInternalServerError(fmt.Sprintf("Knowledge QA service panicked: %v\n%s", r, string(buf))), nil) - } - }() - - // For pure-chat path (no KB, no web search), VLM analysis isn't handled by the - // rewrite pipeline step, so run it here with progress events. - // RAG paths (with KB/web search, including agent-resolved KBs) defer VLM analysis - // to the rewrite step to avoid duplicate progress events. - hasRequestKBs := len(reqCtx.knowledgeBaseIDs) > 0 || len(reqCtx.knowledgeIDs) > 0 - agentWillResolveKBs := false - if !hasRequestKBs && reqCtx.customAgent != nil && !reqCtx.customAgent.Config.RetrieveKBOnlyWhenMentioned { - mode := reqCtx.customAgent.Config.KBSelectionMode - switch mode { - case "all": - agentWillResolveKBs = true - case "selected", "": - // "" keeps backward-compatible behavior (same as selected). - agentWillResolveKBs = len(reqCtx.customAgent.Config.KnowledgeBases) > 0 - case "none": - agentWillResolveKBs = false - default: - agentWillResolveKBs = len(reqCtx.customAgent.Config.KnowledgeBases) > 0 - } - } - isPureChatPath := !hasRequestKBs && !agentWillResolveKBs && !reqCtx.webSearchEnabled - if isPureChatPath && len(reqCtx.images) > 0 && - reqCtx.customAgent != nil && reqCtx.customAgent.Config.VLMModelID != "" { - toolCallID := uuid.New().String() - streamCtx.eventBus.Emit(streamCtx.asyncCtx, event.Event{ - Type: event.EventAgentToolCall, - SessionID: sessionID, - Data: event.AgentToolCallData{ - ToolCallID: toolCallID, - ToolName: "image_analysis", - }, - }) - vlmStart := time.Now() - h.analyzeImageAttachments(streamCtx.asyncCtx, reqCtx.images, - reqCtx.customAgent.Config.VLMModelID, reqCtx.query) - streamCtx.eventBus.Emit(streamCtx.asyncCtx, event.Event{ - Type: event.EventAgentToolResult, - SessionID: sessionID, - Data: event.AgentToolResultData{ - ToolCallID: toolCallID, - ToolName: "image_analysis", - Output: "已分析图片内容", - Success: true, - Duration: time.Since(vlmStart).Milliseconds(), - }, - }) - } - - imageURLs, imageDescription := extractImageURLsAndOCRText(reqCtx.images) - err := h.sessionService.KnowledgeQA( - streamCtx.asyncCtx, - reqCtx.session, - reqCtx.query, - reqCtx.knowledgeBaseIDs, - reqCtx.knowledgeIDs, - reqCtx.assistantMessage.ID, - reqCtx.summaryModelID, - reqCtx.webSearchEnabled, - streamCtx.eventBus, - reqCtx.customAgent, - reqCtx.enableMemory, - imageURLs, imageDescription, - reqCtx.userMessageID, - ) - if err != nil { - logger.ErrorWithFields(streamCtx.asyncCtx, err, nil) - streamCtx.eventBus.Emit(streamCtx.asyncCtx, event.Event{ - Type: event.EventError, - SessionID: sessionID, - Data: event.ErrorData{ - Error: err.Error(), - Stage: "knowledge_qa_execution", - SessionID: sessionID, - }, - }) - } - }() - - // Handle SSE events (blocking) - shouldWaitForTitle := generateTitle && reqCtx.session.Title == "" - h.handleAgentEventsForSSE(ctx, reqCtx.c, sessionID, reqCtx.assistantMessage.ID, - reqCtx.requestID, streamCtx.eventBus, shouldWaitForTitle) -} - -// executeAgentModeQA executes the agent mode -func (h *Handler) executeAgentModeQA(reqCtx *qaRequestContext) { - ctx := reqCtx.ctx - sessionID := reqCtx.sessionID - - // Emit agent query event - if err := event.Emit(ctx, event.Event{ - Type: event.EventAgentQuery, - SessionID: sessionID, - RequestID: reqCtx.requestID, - Data: event.AgentQueryData{ + // Agent mode: emit agent query event before message creation + if mode == qaModeAgent { + if err := event.Emit(ctx, event.Event{ + Type: event.EventAgentQuery, SessionID: sessionID, - Query: reqCtx.query, RequestID: reqCtx.requestID, - }, - }); err != nil { - logger.Errorf(ctx, "Failed to emit agent query event: %v", err) - return + Data: event.AgentQueryData{ + SessionID: sessionID, + Query: reqCtx.query, + RequestID: reqCtx.requestID, + }, + }); err != nil { + logger.Errorf(ctx, "Failed to emit agent query event: %v", err) + return + } } // Create user message @@ -590,80 +444,107 @@ func (h *Handler) executeAgentModeQA(reqCtx *qaRequestContext) { } reqCtx.assistantMessage = assistantMessagePtr - logger.Infof(ctx, "Calling agent QA service, session ID: %s", sessionID) + if mode == qaModeNormal { + logger.Infof(ctx, "Using knowledge bases: %v", reqCtx.knowledgeBaseIDs) + } else { + logger.Infof(ctx, "Calling agent QA service, session ID: %s", sessionID) + } - // Setup SSE stream (agent mode always generates title) - streamCtx := h.setupSSEStream(reqCtx, true) + // Setup SSE stream + streamCtx := h.setupSSEStream(reqCtx, generateTitle) - // Execute AgentQA asynchronously + // Normal mode: register completion handler on EventAgentFinalAnswer + // (Agent mode handles completion in the defer block instead) + if mode == qaModeNormal { + var completionHandled bool + streamCtx.eventBus.On(event.EventAgentFinalAnswer, func(ctx context.Context, evt event.Event) error { + data, ok := evt.Data.(event.AgentFinalAnswerData) + if !ok { + return nil + } + streamCtx.assistantMessage.Content += data.Content + if data.IsFallback { + streamCtx.assistantMessage.IsFallback = true + } + if data.Done { + if completionHandled { + return nil + } + completionHandled = true + + logger.Infof(streamCtx.asyncCtx, "Knowledge QA service completed for session: %s", sessionID) + updateCtx := context.WithValue(streamCtx.asyncCtx, types.TenantIDContextKey, reqCtx.session.TenantID) + h.completeAssistantMessage(updateCtx, streamCtx.assistantMessage, reqCtx.query) + streamCtx.eventBus.Emit(streamCtx.asyncCtx, event.Event{ + Type: event.EventAgentComplete, + SessionID: sessionID, + Data: event.AgentCompleteData{FinalAnswer: streamCtx.assistantMessage.Content}, + }) + } + return nil + }) + } + + // Execute QA asynchronously go func() { defer func() { if r := recover(); r != nil { - buf := make([]byte, 1024) + buf := make([]byte, 10240) runtime.Stack(buf, true) + stageName := "Knowledge QA" + if mode == qaModeAgent { + stageName = "Agent QA" + } logger.ErrorWithFields(streamCtx.asyncCtx, - errors.NewInternalServerError(fmt.Sprintf("Agent QA service panicked: %v\n%s", r, string(buf))), + errors.NewInternalServerError(fmt.Sprintf("%s service panicked: %v\n%s", stageName, r, string(buf))), map[string]interface{}{"session_id": sessionID}) } - // Use session's tenant for message update (session belongs to session.TenantID; asyncCtx may have effectiveTenantID when using shared agent) - updateCtx := context.WithValue(streamCtx.asyncCtx, types.TenantIDContextKey, reqCtx.session.TenantID) - h.completeAssistantMessage(updateCtx, streamCtx.assistantMessage, reqCtx.query) - logger.Infof(streamCtx.asyncCtx, "Agent QA service completed for session: %s", sessionID) + // Agent mode: complete the assistant message in defer (normal mode does it via event handler) + if mode == qaModeAgent { + updateCtx := context.WithValue(streamCtx.asyncCtx, types.TenantIDContextKey, reqCtx.session.TenantID) + h.completeAssistantMessage(updateCtx, streamCtx.assistantMessage, reqCtx.query) + logger.Infof(streamCtx.asyncCtx, "Agent QA service completed for session: %s", sessionID) + } }() - // Run VLM analysis inside the async flow so SSE stream is already up - // and the user can see progress. Emit tool_call/tool_result events. - if len(reqCtx.images) > 0 && reqCtx.customAgent != nil && reqCtx.customAgent.Config.VLMModelID != "" { - toolCallID := uuid.New().String() - streamCtx.eventBus.Emit(streamCtx.asyncCtx, event.Event{ - Type: event.EventAgentToolCall, - SessionID: sessionID, - Data: event.AgentToolCallData{ - ToolCallID: toolCallID, - ToolName: "image_analysis", - Iteration: 0, - }, - }) - vlmStart := time.Now() - h.analyzeImageAttachments(streamCtx.asyncCtx, reqCtx.images, - reqCtx.customAgent.Config.VLMModelID, reqCtx.query) - streamCtx.eventBus.Emit(streamCtx.asyncCtx, event.Event{ - Type: event.EventAgentToolResult, - SessionID: sessionID, - Data: event.AgentToolResultData{ - ToolCallID: toolCallID, - ToolName: "image_analysis", - Output: "已查看图片内容", - Success: true, - Duration: time.Since(vlmStart).Milliseconds(), - Iteration: 0, - }, - }) + // Run VLM image analysis if applicable + h.runVLMAnalysisIfNeeded(streamCtx, reqCtx, mode) + + // Build QA request and invoke the appropriate service + imageURLs, imageDescription := extractImageURLsAndOCRText(reqCtx.images) + qaReq := &types.QARequest{ + Session: reqCtx.session, + Query: reqCtx.query, + AssistantMessageID: reqCtx.assistantMessage.ID, + SummaryModelID: reqCtx.summaryModelID, + CustomAgent: reqCtx.customAgent, + KnowledgeBaseIDs: reqCtx.knowledgeBaseIDs, + KnowledgeIDs: reqCtx.knowledgeIDs, + ImageURLs: imageURLs, + ImageDescription: imageDescription, + UserMessageID: reqCtx.userMessageID, + WebSearchEnabled: reqCtx.webSearchEnabled, + EnableMemory: reqCtx.enableMemory, } - imageURLs, imageDescription := extractImageURLsAndOCRText(reqCtx.images) - err := h.sessionService.AgentQA( - streamCtx.asyncCtx, - reqCtx.session, - reqCtx.query, - reqCtx.assistantMessage.ID, - reqCtx.summaryModelID, - streamCtx.eventBus, - reqCtx.customAgent, - reqCtx.knowledgeBaseIDs, - reqCtx.knowledgeIDs, - imageURLs, imageDescription, - reqCtx.userMessageID, - reqCtx.webSearchEnabled, - ) - if err != nil { - logger.ErrorWithFields(streamCtx.asyncCtx, err, nil) + var serviceErr error + var stageName string + if mode == qaModeNormal { + stageName = "knowledge_qa_execution" + serviceErr = h.sessionService.KnowledgeQA(streamCtx.asyncCtx, qaReq, streamCtx.eventBus) + } else { + stageName = "agent_execution" + serviceErr = h.sessionService.AgentQA(streamCtx.asyncCtx, qaReq, streamCtx.eventBus) + } + + if serviceErr != nil { + logger.ErrorWithFields(streamCtx.asyncCtx, serviceErr, nil) streamCtx.eventBus.Emit(streamCtx.asyncCtx, event.Event{ Type: event.EventError, SessionID: sessionID, Data: event.ErrorData{ - Error: err.Error(), - Stage: "agent_execution", + Error: serviceErr.Error(), + Stage: stageName, SessionID: sessionID, }, }) @@ -671,8 +552,78 @@ func (h *Handler) executeAgentModeQA(reqCtx *qaRequestContext) { }() // Handle SSE events (blocking) + shouldWaitForTitle := generateTitle && reqCtx.session.Title == "" h.handleAgentEventsForSSE(ctx, reqCtx.c, sessionID, reqCtx.assistantMessage.ID, - reqCtx.requestID, streamCtx.eventBus, reqCtx.session.Title == "") + reqCtx.requestID, streamCtx.eventBus, shouldWaitForTitle) +} + +// runVLMAnalysisIfNeeded runs VLM image analysis within the async goroutine, +// emitting tool_call/tool_result events so the user can see progress. +// For normal mode, VLM only runs on the pure-chat path (no KB, no web search); +// RAG paths defer VLM to the pipeline rewrite step. +// For agent mode, VLM always runs when images and a VLM model are present. +func (h *Handler) runVLMAnalysisIfNeeded(streamCtx *sseStreamContext, reqCtx *qaRequestContext, mode qaMode) { + if len(reqCtx.images) == 0 || reqCtx.customAgent == nil || reqCtx.customAgent.Config.VLMModelID == "" { + return + } + + sessionID := reqCtx.sessionID + + // In normal mode, only run VLM for pure-chat path + if mode == qaModeNormal { + hasRequestKBs := len(reqCtx.knowledgeBaseIDs) > 0 || len(reqCtx.knowledgeIDs) > 0 + agentWillResolveKBs := false + if !hasRequestKBs && reqCtx.customAgent != nil && !reqCtx.customAgent.Config.RetrieveKBOnlyWhenMentioned { + switch reqCtx.customAgent.Config.KBSelectionMode { + case "all": + agentWillResolveKBs = true + case "selected", "": + agentWillResolveKBs = len(reqCtx.customAgent.Config.KnowledgeBases) > 0 + case "none": + agentWillResolveKBs = false + default: + agentWillResolveKBs = len(reqCtx.customAgent.Config.KnowledgeBases) > 0 + } + } + if hasRequestKBs || agentWillResolveKBs || reqCtx.webSearchEnabled { + return // VLM will be handled by the pipeline rewrite step + } + } + + // Emit VLM tool call/result events + toolCallID := uuid.New().String() + iteration := 0 // agent mode uses iteration field + + streamCtx.eventBus.Emit(streamCtx.asyncCtx, event.Event{ + Type: event.EventAgentToolCall, + SessionID: sessionID, + Data: event.AgentToolCallData{ + ToolCallID: toolCallID, + ToolName: "image_analysis", + Iteration: iteration, + }, + }) + + vlmStart := time.Now() + h.analyzeImageAttachments(streamCtx.asyncCtx, reqCtx.images, + reqCtx.customAgent.Config.VLMModelID, reqCtx.query) + + outputMsg := "已分析图片内容" + if mode == qaModeAgent { + outputMsg = "已查看图片内容" + } + streamCtx.eventBus.Emit(streamCtx.asyncCtx, event.Event{ + Type: event.EventAgentToolResult, + SessionID: sessionID, + Data: event.AgentToolResultData{ + ToolCallID: toolCallID, + ToolName: "image_analysis", + Output: outputMsg, + Success: true, + Duration: time.Since(vlmStart).Milliseconds(), + Iteration: iteration, + }, + }) } // completeAssistantMessage marks an assistant message as complete, updates it, diff --git a/internal/types/interfaces/session.go b/internal/types/interfaces/session.go index 06bf034c..1a2bf10a 100644 --- a/internal/types/interfaces/session.go +++ b/internal/types/interfaces/session.go @@ -32,43 +32,17 @@ type SessionService interface { // It emits an event when the title is generated // modelID: optional model ID to use for title generation (if empty, uses first available KnowledgeQA model) GenerateTitleAsync(ctx context.Context, session *types.Session, userQuery string, modelID string, eventBus *event.EventBus) - // KnowledgeQA performs knowledge-based question answering - // knowledgeBaseIDs: list of knowledge base IDs to search (supports multi-KB) - // knowledgeIDs: list of specific knowledge (file) IDs to search - // summaryModelID: optional summary model ID override (if empty, uses session/KB default) - // webSearchEnabled: whether to enable web search to supplement knowledge base results - // customAgent: optional custom agent for config override (multiTurnEnabled, historyTurns) - // enableMemory: whether to enable memory feature for this request - // Events are emitted through eventBus (references, answer chunks, completion) - KnowledgeQA(ctx context.Context, - session *types.Session, query string, knowledgeBaseIDs []string, knowledgeIDs []string, - assistantMessageID string, summaryModelID string, webSearchEnabled bool, eventBus *event.EventBus, - customAgent *types.CustomAgent, enableMemory bool, - imageURLs []string, imageDescription string, userMessageID string, - ) error + // KnowledgeQA performs knowledge-based question answering. + // Events are emitted through eventBus (references, answer chunks, completion). + KnowledgeQA(ctx context.Context, req *types.QARequest, eventBus *event.EventBus) error // KnowledgeQAByEvent performs knowledge-based question answering by event KnowledgeQAByEvent(ctx context.Context, chatManage *types.ChatManage, eventList []types.EventType) error // SearchKnowledge performs knowledge-based search, without summarization // knowledgeBaseIDs: list of knowledge base IDs to search (supports multi-KB) // knowledgeIDs: list of specific knowledge (file) IDs to search SearchKnowledge(ctx context.Context, knowledgeBaseIDs []string, knowledgeIDs []string, query string) ([]*types.SearchResult, error) - // AgentQA performs agent-based question answering with conversation history and streaming support - // eventBus is optional - if nil, uses service's default EventBus - // customAgent is optional - if provided, uses custom agent configuration instead of tenant defaults - // summaryModelID is optional - if provided, overrides the model from customAgent config - AgentQA( - ctx context.Context, - session *types.Session, - query string, - assistantMessageID string, - summaryModelID string, - eventBus *event.EventBus, - customAgent *types.CustomAgent, - knowledgeBaseIDs []string, - knowledgeIDs []string, - imageURLs []string, imageDescription string, userMessageID string, - webSearchEnabled bool, - ) error + // AgentQA performs agent-based question answering with conversation history and streaming support. + AgentQA(ctx context.Context, req *types.QARequest, eventBus *event.EventBus) error // ClearContext clears the LLM context for a session ClearContext(ctx context.Context, sessionID string) error } diff --git a/internal/types/qa_request.go b/internal/types/qa_request.go new file mode 100644 index 00000000..56cab9ac --- /dev/null +++ b/internal/types/qa_request.go @@ -0,0 +1,19 @@ +package types + +// QARequest consolidates all parameters for KnowledgeQA and AgentQA service calls, +// replacing the previous 14-parameter method signatures. +// EventBus is passed separately to avoid circular dependency with the event package. +type QARequest struct { + Session *Session // The conversation session + Query string // User query text + AssistantMessageID string // Pre-created assistant message ID + SummaryModelID string // Optional model override; empty = use agent/KB default + CustomAgent *CustomAgent // Optional custom agent for config override + KnowledgeBaseIDs []string // Knowledge base IDs to search (from request + @mentions) + KnowledgeIDs []string // Specific knowledge (file) IDs to search + ImageURLs []string // Image URLs for multimodal input + ImageDescription string // VLM-generated image description (fallback for non-vision models) + UserMessageID string // Created user message ID + WebSearchEnabled bool // Whether web search is enabled for this request + EnableMemory bool // Whether memory feature is enabled +}