optimize prompts and empty tool response handling

Author: stringl1l1l1l

ai/agent/react/react.go

@@ -16,6 +16,7 @@ import (
 	"github.com/firebase/genkit/go/ai"
 	"github.com/firebase/genkit/go/core"
 	"github.com/firebase/genkit/go/genkit"
+	"github.com/openai/openai-go"
 )
 
 type ThinkIn = schema.ThinkInput
@@ -179,6 +180,9 @@ func buildThinkPrompt(registry *genkit.Genkit, tools ...ai.ToolRef) (ai.Prompt,
 		ai.WithInputType(ThinkIn{}),
 		ai.WithOutputType(ThinkOut{}),
 		ai.WithPrompt(fmt.Sprintf("available tools: %s", string(toolsJson))),
+		ai.WithConfig(&openai.ChatCompletionNewParams{
+			Temperature: openai.Float(0.2),
+		}),
 	), nil
 }
 
@@ -203,6 +207,9 @@ func buildFeedBackPrompt(registry *genkit.Genkit) (ai.Prompt, error) {
 	return genkit.DefinePrompt(registry, "agentFeedback",
 		ai.WithSystem(string(data)),
 		ai.WithInputType(ThinkIn{}),
+		ai.WithConfig(&openai.ChatCompletionNewParams{
+			Temperature: openai.Float(0.7),
+		}),
 	), nil
 }
 
@@ -214,6 +221,9 @@ func buildObservePrompt(registry *genkit.Genkit) (ai.Prompt, error) {
 	return genkit.DefinePrompt(registry, "observe",
 		ai.WithSystem(string(data)),
 		ai.WithOutputType(schema.Observation{}),
+		ai.WithConfig(&openai.ChatCompletionNewParams{
+			Temperature: openai.Float(0.5),
+		}),
 	), nil
 }
 
@@ -327,7 +337,7 @@ func act(g *genkit.Genkit, mcpToolManager *tools.MCPToolManager, toolPrompt ai.P
 				return nil, fmt.Errorf("failed to execute tool selection prompt: %w", err)
 			}
 			if len(toolReqs.ToolRequests()) == 0 {
-				return ActOut{Thought: toolReqs.Text()}, fmt.Errorf("agent don't have available tools")
+				return ActOut{Thought: fmt.Sprintf("have unavailable tools in %v, please check available tools list", input.SuggestedTools)}, nil
 			}
 			manager.GetLogger().Info("tool requests:", "req", toolReqs.ToolRequests())
 

ai/prompts/agentFeedback.txt

@@ -27,6 +27,7 @@ Pay close attention to these schema fields in the conversation:
 - `heartbeat`: Whether investigation continues (true) or completes (false)
 - `focus`: What the agent plans to focus on next
 - `evidence`: Accumulated evidence so far
+- IMPORTANT`final_answer`: When this field exists and has content, you MUST include it in your response. This is the definitive answer to the user's question.
 
 # Smart Communication Rules
 1. **Detect Progress**: If multiple similar thoughts/actions occurred, acknowledge "continuing analysis" rather than repeating details
@@ -37,11 +38,13 @@ Pay close attention to these schema fields in the conversation:
 
 # Output Style
 Use natural Chinese with selective markdown formatting:
+- IMPORTANT: **Final Answer Requirement**: When `final_answer` is not empty, include it completely and prominently in your response
 - Start with current status context, not generic descriptions
 - Use conversational transitions like "现在开始...", "刚刚获得...", "接下来将..."  
 - Apply **bold** for key findings, services, or metrics
 - Use bullet points only when listing multiple items
 - Include relevant emoji sparingly (🔍 📊 ⚠️ ✅) for status indication
+- For final answers containing code/YAML, preserve all formatting and structure
 
 # Response Adaptation
 **First Think**: Introduce the investigation approach

ai/prompts/agentThink.txt

@@ -8,15 +8,17 @@ You are the BRAIN of the ReAct agent. Think deeply, reason carefully, and provid
 **CRITICAL**: Build upon previous findings. Do NOT repeat identical analysis if tools have already provided concrete data. When lacking domain knowledge, actively seek information through RAG tools.
 **TOOL NAME ACCURACY**: All tool names in suggested_tools MUST exactly match the available tool names in the system.
 **HISTORICAL CONTEXT PRIORITY**: When users reference previous conversations (using words like "previous", "before", "earlier", "之前"), ALWAYS prioritize memory retrieval tools.
+**CONTEXT INSUFFICIENCY DETECTION**: When you lack sufficient context to provide a complete answer (user mentions specific configurations, solutions, or discussions without providing details), ALWAYS suggest memory_all_by_session_id to retrieve missing context.
 
 1. **Be Analytical**: Parse complex inputs and extract key intentions and context, especially detecting historical references
 2. **Be Evidence-Based**: Ground all reasoning in observed data and patterns
 3. **Be Knowledge-Aware**: Recognize when you lack sufficient domain knowledge and proactively suggest RAG tools to retrieve relevant information
 4. **Be Memory-Conscious**: Immediately identify when historical context is needed and suggest appropriate memory tools
-5. **Be Comprehensive**: Provide rich, structured analysis that guides downstream components, enhanced by retrieved knowledge
-6. **Be Strategic**: Identify investigation priorities and strategic directions, including knowledge retrieval needs
-7. **Be Contextual**: Consider system state, dependencies, and operational patterns
-8. **Be Prescriptive**: Offer clear guidance for tool selection and execution strategies, prioritizing memory retrieval for historical queries and knowledge retrieval when needed
+5. **Be Context-Aware**: When users reference specific items without providing details, ALWAYS assume missing context and retrieve memory first
+6. **Be Comprehensive**: Provide rich, structured analysis that guides downstream components, enhanced by retrieved knowledge
+7. **Be Strategic**: Identify investigation priorities and strategic directions, including knowledge retrieval needs
+8. **Be Contextual**: Consider system state, dependencies, and operational patterns
+9. **Be Prescriptive**: Offer clear guidance for tool selection and execution strategies, prioritizing memory retrieval for historical queries and knowledge retrieval when needed
 
 # Input Handling
 **You receive**: User questions, Tool Responses messages, or other historical context from previous ReAct cycles
@@ -29,6 +31,7 @@ If the historical context is long, prioritize the most recent and relevant messa
 Parse and understand:
 - **User Intent**: What is the user actually trying to achieve?
 - **Historical Reference Detection**: Does the user reference "previous", "before", "earlier", "之前", or similar terms indicating they want information from past conversations? **This requires immediate memory retrieval**
+- **Context Sufficiency Check**: Do I have enough context to understand the user's request? If the user mentions specific items (configurations, solutions, errors, services) without providing details, I need to retrieve conversation history
 - **System Context**: Current operational state and known issues
 - **Tool Responses**: What concrete evidence has been collected? **Extract specific values from tool results**
 - **Historical Context**: Previous analysis patterns and findings
@@ -38,6 +41,7 @@ Parse and understand:
 ## 2. Strategic Analysis
 Determine investigation strategy:
 - **Priority Assessment**: What requires immediate attention?
+- **Context Gap Analysis**: Am I missing critical context to understand the user's request? If so, memory retrieval is the FIRST priority before any other analysis
 - **Memory Search Detection**: Does the user request reference previous conversations, configurations, or recommendations? This requires MEMORY_SEARCH intent classification.
 - **Domain Identification**: Is this primarily a Kubernetes, Dubbo, or general infrastructure question? Choose the most relevant knowledge domain first.
 - **Evidence Gaps**: What critical information is missing? (Consider what we already have)
@@ -67,6 +71,8 @@ Determine investigation strategy:
   - References to past analysis, recommendations, or troubleshooting steps
   - Requests to review or modify previously provided solutions
   - Any inquiry that requires context from earlier in the conversation or previous sessions
+  - **When user mentions specific items without details ("that configuration", "the solution", "this issue", "this file", "my setup") - ALWAYS retrieve memory first**
+  - **When you cannot provide a complete answer due to missing context - ALWAYS suggest memory_all_by_session_id**
   - **Always suggest memory_all_by_session_id or similar memory tools when historical context is needed**
 - **RAG Knowledge Retrieval**: When you lack specific domain knowledge, technical details, configuration information, or best practices to properly analyze the situation, actively suggest RAG tools to retrieve relevant knowledge. **Choose the most appropriate knowledge domain based on the user's question**:
   - **For Kubernetes questions**: Use Kubernetes documentation tools for cluster management, deployments, networking, storage, etc.
@@ -83,18 +89,24 @@ All string fields must be valid strings, never use null values.
 
 **Note**: You do NOT control the ReAct flow status or provide final answers. Your role is purely analytical - to understand the situation and guide the next investigation steps. The Observe component will handle flow control and final conclusions.
 
+Available tools name list: [
+    "retrieve_basic_concept_from_k8s_doc",
+    "memory_all_by_session_id",
+    "prometheus_query_service_traffic",
+    "query_timeseries_database",
+    "application_performance_profiling",
+    "jvm_performance_analysis",
+    "trace_dependency_view",
+    "trace_latency_analysis",
+    "database_connection_pool_analysis",
+    "kubernetes_get_pod_resources",
+    "dubbo_service_status",
+    "query_log_database",
+    "search_archived_logs",
+    "query_knowledge_base"
+]
 
 # Examples
-<example>
-input: {"user_input": "Analyze the latency of the user-service"}
-output: {
-    "thought": "The user is requesting latency analysis for 'user-service'. This indicates a performance investigation intent. I need to identify the target service and suggest appropriate tools for latency analysis including metrics and dependency investigation.",
-    "intent": "PERFORMANCE_INVESTIGATION",
-    "target_services": ["user-service"],
-    "suggested_tools": ["prometheus_query_service_latency", "prometheus_query_service_traffic", "trace_dependency_view"]
-}
-<example>
-
 <example>
 input: {"user_input": "What's you name?"}
 output: {
@@ -105,16 +117,6 @@ output: {
 }
 <example>
 
-<example>
-input: {"user_input": "Why is my service getting connection timeout errors?"}
-output: {
-    "thought": "The user is experiencing connection timeout errors, which could be due to various factors including network issues, service configuration, resource constraints, or architectural problems. Since this is a general troubleshooting question without specific technology context, I should start with infrastructure-level investigation and then move to service-specific analysis if needed.",
-    "intent": "TROUBLESHOOTING_INVESTIGATION",
-    "target_services": [],
-    "suggested_tools": ["retrieve_basic_concept_from_k8s_doc", "prometheus_query_service_latency", "prometheus_query_service_errors"]
-}
-<example>
-
 <example>
 input: {"user_input": "What is the deployment in k8s?"}
 output: {
@@ -133,4 +135,14 @@ output: {
     "target_services": [],
     "suggested_tools": ["memory_all_by_session_id"]
 }
+<example>
+
+<example>
+input: {"user_input": "How should I modify my current setup for better performance?"}
+output: {
+    "thought": "The user asks about modifying 'my current setup' but I don't have information about their specific setup, configuration, or environment. I need to retrieve conversation history to understand their current setup before I can provide recommendations for performance improvements.",
+    "intent": "MEMORY_SEARCH",
+    "target_services": [],
+    "suggested_tools": ["memory_all_by_session_id"]
+}
 <example>

ai/schema/react.go

@@ -184,7 +184,7 @@ func StreamEnd() *StreamFeedback {
 
 func StreamFinal(final *Observation) *StreamFeedback {
 	defer func() { index++ }()
-	return &StreamFeedback{index: index, done: true, text: final.FinalAnswer, final: final}
+	return &StreamFeedback{index: index, done: true, text: "", final: final}
 }
 
 func (sf *StreamFeedback) Text() string {

ai/server/handlers.go

@@ -93,12 +93,6 @@ func (h *AgentHandler) StreamChat(c *gin.Context) {
 				continue
 			}
 			if feedback.IsFinal() {
-				if err := sseHandler.HandleText(feedback.Text(), feedback.Index()); err != nil {
-					manager.GetLogger().Error("Failed to handle text", "error", err)
-				}
-				if err := sseHandler.HandleContentBlockStop(feedback.Index()); err != nil {
-					manager.GetLogger().Error("Failed to handle content block stop", "error", err)
-				}
 				h.MessageDelta(sseHandler, feedback.Final())
 			} else if feedback.IsDone() {
 				if err := sseHandler.HandleContentBlockStop(feedback.Index()); err != nil {