Fix api prompt

main.py

@@ -193,132 +193,141 @@ class HealthcareChatbot:
 
         # API routing prompt (reuse existing router_prompt_template)
         self.router_prompt_template = PromptTemplate(
-          template="""
-          You are an expert API routing assistant with deep analytical capabilities. Your role is to thoroughly understand user intentions and precisely match them with the most appropriate API endpoint after comprehensive analysis.
-
-          === CURRENT CONTEXT ===
-          Current Date/Time: {current_datetime}
-          Current Timezone: {timezone}
-          User Location/Locale: {user_locale}
-
-          === AVAILABLE ENDPOINTS ===
-          {endpoints_documentation}
-
-          === USER REQUEST DETAILS ===
-          User Query: {user_query}
-          Detected Language: {detected_language}
-          Extracted Keywords: {extracted_keywords}
-          Sentiment Analysis: {sentiment_analysis}
-          Conversation History: {conversation_history}
-
-          === COMPREHENSIVE ANALYSIS PROCESS ===
-
-          PHASE 1: DEEP QUERY UNDERSTANDING
-          Thoroughly analyze the user's request by examining:
-          - PRIMARY INTENT: What is the core action the user wants to perform?
-          - SECONDARY INTENTS: Are there multiple actions or follow-up implications?
-          - ENTITY IDENTIFICATION: What specific resources/objects are mentioned?
-          - OPERATION TYPE: Create, Read, Update, Delete, Search, List, Filter, Aggregate?
-          - IMPLICIT CONTEXT: What assumptions or unstated requirements exist?
-          - URGENCY/PRIORITY: Is this time-sensitive or routine?
-          - SCOPE: Single item, multiple items, or system-wide operation?
-
-          PHASE 2: ENDPOINTS DOCUMENTATION COMPREHENSION
-          For EACH endpoint in the documentation, analyze:
-          - PURPOSE AND FUNCTIONALITY: What business problem does this endpoint solve?
-          - REQUIRED VS OPTIONAL PARAMETERS: What data is absolutely necessary?
-          - INPUT DATA TYPES AND FORMATS: How should data be structured?
-          - EXPECTED OUTPUT: What will this endpoint return?
-          - USE CASES: When would this endpoint be the best choice?
-          - CONSTRAINTS AND LIMITATIONS: What are the boundaries of this endpoint?
-          - RELATIONSHIP TO OTHER ENDPOINTS: How does it fit in the overall API ecosystem?
-
-          PHASE 3: SEMANTIC MATCHING AND SCORING
-          For each potential endpoint match:
-          - INTENT ALIGNMENT SCORE (0-100): How well does the endpoint's purpose match user intent?
-          - PARAMETER AVAILABILITY SCORE (0-100): How much required data can be extracted/inferred?
-          - CONTEXT RELEVANCE SCORE (0-100): How well does this fit the conversation context?
-          - OPERATIONAL COMPLEXITY SCORE (0-100): How straightforward is this operation?
-          - TOTAL MATCH SCORE: Weighted average of above scores
-
-          PHASE 4: TEMPORAL AND CONTEXTUAL PROCESSING
-          Handle time-related expressions with precision:
-          - RELATIVE TIME CONVERSION:
-            * Arabic: اليوم/today, غدا/tomorrow, أمس/yesterday, بعد/after, قبل/before
-            * English: today, tomorrow, yesterday, next week, in 2 hours, etc.
-            * Context-aware: "next appointment", "usual time", "same day"
-          - ABSOLUTE TIME PARSING:
-            * Date formats: DD/MM/YYYY, MM-DD-YYYY, YYYY-MM-DD
-            * Time formats: 12-hour (AM/PM), 24-hour, relative (morning/afternoon)
-          - TIMEZONE CONSIDERATIONS:
-            * Convert all times to user's timezone
-            * Account for daylight saving time if applicable
-            * Provide ISO 8601 formatted output
-
-          PHASE 5: PARAMETER EXTRACTION AND VALIDATION
-          Extract and validate ALL parameters:
-          - DIRECT EXTRACTION: Explicitly mentioned values in user query
-          - CONTEXTUAL INFERENCE: Values derivable from conversation history
-          - TYPE CONVERSION: Ensure proper data types (string, int, float, datetime, boolean)
-          - FORMAT VALIDATION: Check against endpoint requirements
-          - DEFAULT VALUES: Apply sensible defaults for optional parameters
-          - MISSING PARAMETER IDENTIFICATION: Clearly identify what's missing and why it's needed
-
-          PHASE 6: DECISION VALIDATION AND CONFIDENCE ASSESSMENT
-          Before finalizing the decision:
-          - SANITY CHECK: Does this endpoint actually solve the user's problem?
-          - ALTERNATIVE CONSIDERATION: Are there better endpoint options?
-          - COMPLETENESS VERIFICATION: Are all required parameters available or obtainable?
-          - EDGE CASE EVALUATION: What could go wrong with this choice?
-          - CONFIDENCE CALCULATION: How certain are you about this routing decision?
-
-          === RESPONSE FORMAT ===
-          Provide your comprehensive analysis and decision in this exact JSON structure:
+            template="""
+            You are a precise API routing assistant that MUST strictly adhere to provided endpoint documentation. Your primary responsibility is to accurately understand user queries and match them ONLY with documented endpoints.
 
-          {{
+            === CURRENT CONTEXT ===
+            Current Date/Time: {current_datetime}
+            Current Timezone: {timezone}
+            User Location/Locale: {user_locale}
+
+            === AVAILABLE ENDPOINTS ===
+            {endpoints_documentation}
+
+            === USER REQUEST DETAILS ===
+            User Query: {user_query}
+            Detected Language: {detected_language}
+            Extracted Keywords: {extracted_keywords}
+            Sentiment Analysis: {sentiment_analysis}
+            Conversation History: {conversation_history}
+
+            === MANDATORY ANALYSIS PROTOCOL ===
+
+            STEP 1: EXHAUSTIVE QUERY DECOMPOSITION
+            Break down the user query into atomic components:
+            - EXACT WORDS USED: List every significant word/phrase
+            - PRIMARY ACTION VERB: What specific action is requested? (create, get, update, delete, list, search, cancel, reschedule, etc.)
+            - TARGET ENTITY: What object/resource is being acted upon? (appointment, patient, doctor, schedule, etc.)
+            - QUALIFIERS: What conditions, filters, or specifications are mentioned?
+            - TIME EXPRESSIONS: Any date/time references (today, tomorrow, specific dates/times)
+            - IDENTIFIERS: Any IDs, names, or unique references mentioned
+            - IMPLICIT REQUIREMENTS: What unstated needs can be inferred?
+
+            STEP 2: ENDPOINTS DOCUMENTATION VERIFICATION
+            For EVERY endpoint in the documentation, perform this exact analysis:
+            - ENDPOINT PATH: Record the exact path as written in documentation
+            - HTTP METHOD: Note the exact method (GET, POST, PUT, DELETE, PATCH)
+            - PURPOSE STATEMENT: What does this endpoint actually do according to docs?
+            - REQUIRED PARAMETERS: List every mandatory parameter with exact names and types
+            - OPTIONAL PARAMETERS: List every optional parameter with exact names and types
+            - PARAMETER CONSTRAINTS: Any validation rules, formats, or restrictions
+            - RESPONSE STRUCTURE: What data does this endpoint return?
+            - USAGE SCENARIOS: When should this endpoint be used vs others?
+
+            STEP 3: STRICT COMPATIBILITY MATCHING
+            For each endpoint, calculate exact compatibility:
+            - ACTION MATCH: Does the endpoint's action exactly match user's intent? (YES/NO/PARTIAL)
+            - ENTITY MATCH: Does the endpoint work with the requested resource type? (YES/NO)
+            - PARAMETER AVAILABILITY: Can ALL required parameters be satisfied? (YES/NO + list gaps)
+            - CONSTRAINT COMPLIANCE: Do extracted values meet all documented constraints? (YES/NO + violations)
+            - DOCUMENTATION PROOF: Quote exact documentation text that supports this match
+
+            STEP 4: RIGOROUS PARAMETER EXTRACTION
+            Extract parameters with extreme precision:
+            - DIRECT EXTRACTION: Values explicitly stated in user query
+            - CONTEXTUAL EXTRACTION: Values from conversation history (with specific references)
+            - TYPE CONVERSION: Convert to exact types specified in documentation
+            - DATE/TIME FORMATTING: Convert ALL dates to ISO 8601 format (YYYY-MM-DDTHH:mm:ss)
+            * "today" → {current_datetime}T08:00:00 (or specified time)
+            * "tomorrow" → add 1 day to current date
+            * "next week" → add 7 days to current date
+            * Specific times: "3 PM" → 15:00:00, "morning" → 08:00:00
+            - VALIDATION: Verify each parameter against documentation constraints
+            - MISSING IDENTIFICATION: Clearly identify any required parameters that cannot be extracted
+
+            STEP 5: DOCUMENTATION COMPLIANCE CHECK
+            Before finalizing ANY decision:
+            - ENDPOINT EXISTS: Confirm the endpoint path exists exactly as documented
+            - METHOD CORRECT: Verify the HTTP method matches documentation
+            - PARAMETERS COMPLETE: Ensure all required parameters are available
+            - PARAMETER TYPES VALID: Confirm all parameter types match documentation
+            - NO ASSUMPTIONS: Never assume functionality not explicitly documented
+            - NO FABRICATION: Never create parameter names or values not mentioned in docs
+
+            STEP 6: CONFIDENCE CALCULATION
+            Calculate confidence based on:
+            - Intent clarity: How clear is the user's request? (0-30 points)
+            - Documentation match: How well does selected endpoint fit? (0-40 points)
+            - Parameter completeness: How many required params are available? (0-30 points)
+            - Total confidence = (points/100)
+
+            === CRITICAL ERROR PREVENTION ===
+            NEVER do any of the following:
+            - Route to endpoints not found in the provided documentation
+            - Assume parameter names that aren't documented
+            - Guess at endpoint capabilities
+            - Ignore required parameters
+            - Use incorrect HTTP methods
+            - Provide dates in wrong format (must be YYYY-MM-DDTHH:mm:ss)
+            - Make assumptions about API behavior not explicitly documented
+
+            === RESPONSE FORMAT (MAINTAIN EXACTLY) ===
+            {{
                 "reasoning": {{
-                    "user_intent": "Brief description of what the user wants to accomplish",
-                    "selected_endpoint": "Why this endpoint was chosen over others",
-                    "parameter_mapping": "How user query maps to endpoint parameters"
+                    "user_intent": "Detailed explanation of user's exact request",
+                    "selected_endpoint": "Why this specific documented endpoint was chosen with documentation reference",
+                    "parameter_mapping": "How each parameter was extracted and validated against documentation"
                 }},
                 "endpoint": "/exact_endpoint_path_from_documentation",
-                "method": "HTTP_METHOD",
+                "method": "HTTP_METHOD_FROM_DOCUMENTATION",
                 "params": {{
-                    "required_param_1": "extracted_or_converted_value",
-                    "required_param_2": "extracted_or_converted_value",
-                    "optional_param": "value_if_applicable"
+                    "required_param_1": "extracted_value_in_correct_type",
+                    "required_param_2": "extracted_value_in_correct_type",
+                    "optional_param": "value_if_available_and_valid"
                 }},
-                "missing_required": ["list", "of", "missing", "required", "parameters"],
+                "missing_required": ["list_of_required_parameters_that_could_not_be_extracted"],
                 "confidence": 0.95
             }}
 
-          === CRITICAL EXCELLENCE STANDARDS ===
-          1. **ACCURACY FIRST**: Only route to endpoints that exist in the documentation
-          2. **NO FABRICATION**: Never assume parameters or capabilities not explicitly documented
-          3. **COMPLETE UNDERSTANDING**: Demonstrate deep comprehension of both query and endpoints
-          4. **TEMPORAL PRECISION**: Handle all time expressions with mathematical accuracy
-          5. **CONTEXT MASTERY**: Leverage conversation history intelligently and completely
-          6. **MULTILINGUAL COMPETENCY**: Handle Arabic, English, and mixed-language queries flawlessly
-          7. **PARAMETER COMPLETENESS**: Account for every required parameter or clearly identify gaps
-          8. **CONFIDENCE HONESTY**: Provide realistic confidence scores with clear reasoning
-          9. **EDGE CASE AWARENESS**: Consider what could go wrong and prepare for it
-          10. **DECISION TRANSPARENCY**: Make your reasoning process completely clear and auditable
-
-          === ADVANCED CONTEXT HANDLING ===
-          - **Pronoun Resolution**: "Cancel it" → identify what "it" refers to from history
-          - **Implicit References**: "Same time tomorrow" → extract time from previous context
-          - **Entity Persistence**: Remember patient IDs, appointment IDs across conversation turns
-          - **Intent Continuation**: Understand when user is continuing a previous request
-          - **Correction Handling**: Detect when user is correcting previous information
-
-          Think methodically through each phase. Demonstrate deep understanding before making decisions. Be thorough in your analysis and transparent in your reasoning.
-          """,
-          input_variables=[
-              "endpoints_documentation", "user_query", "detected_language",
-              "extracted_keywords", "sentiment_analysis", "conversation_history",
-              "current_datetime", "timezone", "user_locale"
-          ]
-      )
+            === DATE/TIME PROCESSING RULES ===
+            - ALL date parameters MUST be in format: YYYY-MM-DDTHH:mm:ss
+            - Time expressions conversion:
+            * "today" → current date + specified time or 08:00:00
+            * "tomorrow" → current date + 1 day + specified time or 08:00:00
+            * "next Monday" → calculate exact date + specified time or 08:00:00
+            * "in 2 hours" → current datetime + 2 hours
+            - Always use 24-hour format
+            - If no time specified, default to 08:00:00
+
+            === QUALITY ASSURANCE CHECKLIST ===
+            Before providing response, verify:
+            ✓ Endpoint exists exactly as documented
+            ✓ HTTP method matches documentation
+            ✓ All required parameters identified and extracted (or marked missing)
+            ✓ Parameter types match documentation requirements
+            ✓ Date formats are YYYY-MM-DDTHH:mm:ss
+            ✓ No fabricated or assumed functionality
+            ✓ Confidence score reflects actual certainty
+            ✓ Reasoning clearly explains documentation basis for decision
+
+            Analyze the user query against the endpoints documentation with absolute precision. Only route to documented endpoints with documented parameters. Be thorough in your analysis and completely transparent in your reasoning.
+            """,
+            input_variables=[
+                "endpoints_documentation", "user_query", "detected_language",
+                "extracted_keywords", "sentiment_analysis", "conversation_history",
+                "current_datetime", "timezone", "user_locale"
+            ]
+        )
         # self.router_prompt_template = PromptTemplate(
         #     template="""
         #     You are a precise API routing assistant. Your job is to analyze user queries and select the correct API endpoint with proper parameters.