Multi-pass is flowing...

src/utils/agents/base.py

@@ -287,7 +287,7 @@ class Agent(BaseModel, ABC):
             message.metadata["timers"]["llm_with_tools"] = f"{(end_time - start_time):.4f}"
             return
             
-    async def generate_llm_response(self, llm: Any, model: str, message: Message) -> AsyncGenerator[Message, None]:
+    async def generate_llm_response(self, llm: Any, model: str, message: Message, temperature = 0.7) -> AsyncGenerator[Message, None]:
         logger.info(f"{self.agent_type} - {inspect.stack()[0].function}")
         
         self.metrics.generate_count.labels(agent=self.agent_type).inc()
@@ -312,7 +312,7 @@ class Agent(BaseModel, ABC):
             message.metadata["options"]={
                 "seed": 8911,
                 "num_ctx": self.context_size,
-                #"temperature": 0.9,  # Higher temperature to encourage tool usage
+                "temperature": temperature # Higher temperature to encourage tool usage
             }
 
             # Create a dict for storing various timing stats

src/utils/agents/job_description.py

@@ -1,15 +1,19 @@
 from __future__ import annotations
-from pydantic import model_validator # type: ignore
+from pydantic import model_validator, Field # type: ignore
-from typing import Literal, ClassVar, Optional, Any, AsyncGenerator, List # NOTE: You must import Optional for late binding to work
+from typing import Dict, Literal, ClassVar, Optional, Any, AsyncGenerator, List # NOTE: You must import Optional for late binding to work
 from datetime import datetime
 import inspect
+import re
+import json
+import traceback
 
-from . base import Agent, agent_registry
+from . base import Agent, agent_registry, LLMMessage
 from .. conversation import Conversation
 from .. message import Message
 from .. setup_logging import setup_logging
 logger = setup_logging()
 
+
 system_generate_resume = """
 You are an objective skills analyzer for resume tailoring. Your task is to 
 analyze a job description and a candidate's background, identifying ONLY 
@@ -95,33 +99,50 @@ When answering queries, follow these steps:
 - Avoid phrases like 'According to the <|context|>' or similar references to the <|context|>, <|job_description|>, <|resume|>, or <|context|> tags.
 """.strip()
 
+system_user_qualifications = """
+You are an objective job requirements analyzer. Your task is to extract and categorize the specific skills, experiences, and qualifications required in a job description WITHOUT any reference to any candidate.
+
+## INSTRUCTIONS:
+
+1. Analyze ONLY the job description provided.
+2. Extract and categorize all requirements and preferences.
+3. DO NOT consider any candidate information - this is a pure job analysis task.
+
+## OUTPUT FORMAT:
+
+```json
+{
+  "job_requirements": {
+    "technical_skills": {
+      "required": ["skill1", "skill2"...],
+      "preferred": ["skill1", "skill2"...]
+    },
+    "experience_requirements": {
+      "required": ["exp1", "exp2"...],
+      "preferred": ["exp1", "exp2"...]
+    },
+    "education_requirements": ["req1", "req2"...],
+    "soft_skills": ["skill1", "skill2"...],
+    "industry_knowledge": ["knowledge1", "knowledge2"...],
+    "responsibilities": ["resp1", "resp2"...],
+    "company_values": ["value1", "value2"...]
+  }
+}
+```
+
+Be specific and detailed in your extraction. Break down compound requirements into individual components.
+For example, "5+ years experience with React, Node.js and MongoDB" should be separated into:
+- Experience: "5+ years software development"
+- Technical skills: "React", "Node.js", "MongoDB"
+
+Avoid vague categorizations and be precise about whether skills are explicitly required or just preferred.
+</|system|>
+
+<|job_description|>
+[INSERT JOB DESCRIPTION HERE]
+</|job_description|>
+"""
 
-# def run_resume_pipeline(job_description, resume, context):
-#     # Stage 1: Analysis
-#     analysis_prompt = create_analysis_prompt(job_description, resume, context)
-#     job_analysis = call_llm_with_prompt(analysis_prompt)
-    
-#     # Validate analysis output
-#     validated_analysis = validate_job_analysis(job_analysis)
-#     if not validated_analysis:
-#         return {"error": "Analysis stage failed validation"}
-    
-#     # Stage 2: Generation
-#     generation_prompt = create_generation_prompt(validated_analysis, resume)
-#     tailored_resume = call_llm_with_prompt(generation_prompt)
-    
-#     # Stage 3: Verification
-#     verification_prompt = create_verification_prompt(validated_analysis, resume, context, tailored_resume)
-#     verification_result = call_llm_with_prompt(verification_prompt)
-    
-#     # Process verification results
-#     if verification_result.get("verification_results", {}).get("overall_assessment") == "APPROVED":
-#         return {"status": "success", "resume": tailored_resume}
-#     else:
-#         # Optional: Implement correction loop
-#         corrected_resume = apply_corrections(tailored_resume, verification_result)
-#         return {"status": "corrected", "resume": corrected_resume}
-    
 class JobDescription(Agent):
   agent_type: Literal["job_description"] = "job_description" # type: ignore
   _agent_type: ClassVar[str] = agent_type  # Add this for registration
@@ -129,6 +150,9 @@ class JobDescription(Agent):
   system_prompt: str = system_generate_resume
   job_description: str
 
+  llm: Any = Field(default=None, exclude=True)
+  model: str = Field(default=None, exclude=True)
+
   @model_validator(mode="after")
   def validate_job_description(self):
     if not self.job_description.strip():
@@ -181,6 +205,8 @@ class JobDescription(Agent):
       if message.status != "done":
         yield message
 
+    self.system_prompt = system_user_qualifications
+
     resume_agent = self.context.get_agent(agent_type="resume")
     if not resume_agent:
       # Switch agent from "Create Resume from Job Desription" mode
@@ -190,14 +216,806 @@ class JobDescription(Agent):
       # Instantiate the "resume" agent, and seed (or reset) its conversation
       # with this message.
       resume_agent = self.context.get_or_create_agent(agent_type="resume", resume=message.response)
-      first_resume_message = message.copy()
+      first_resume_message = message.model_copy()
       first_resume_message.prompt = "Generate a resume for the job description."
       resume_agent.conversation.add(first_resume_message)
       message.response = "Resume generated."
-
+    
     # Return the final message
     yield message
     return
 
+  # BEGIN
+
+  # Helper functions
+  def extract_json_from_text(self, text: str) -> str:
+      """Extract JSON string from text that may contain other content."""
+      json_pattern = r'```json\s*([\s\S]*?)\s*```'
+      match = re.search(json_pattern, text)
+      if match:
+          return match.group(1).strip()
+      
+      # Try to find JSON without the markdown code block
+      json_pattern = r'({[\s\S]*})'
+      match = re.search(json_pattern, text)
+      if match:
+          return match.group(1).strip()
+      
+      raise ValueError("No JSON found in the response")
+
+  def validate_job_requirements(self, job_requirements: Dict) -> None:
+      """Validate the structure of job requirements."""
+      required_keys = ["job_requirements"]
+      
+      if not all(key in job_requirements for key in required_keys):
+          missing = [key for key in required_keys if key not in job_requirements]
+          raise ValueError(f"Missing required keys in job requirements: {missing}")
+      
+      # Additional validation can be added here
+
+  def validate_candidate_qualifications(self, candidate_qualifications: Dict) -> None:
+      """Validate the structure of candidate qualifications."""
+      required_keys = ["candidate_qualifications"]
+      
+      if not all(key in candidate_qualifications for key in required_keys):
+          missing = [key for key in required_keys if key not in candidate_qualifications]
+          raise ValueError(f"Missing required keys in candidate qualifications: {missing}")
+      
+      # Additional validation can be added here
+
+  def validate_skills_mapping(self, skills_mapping: Dict) -> None:
+      """Validate the structure of skills mapping."""
+      required_keys = ["skills_mapping", "resume_recommendations"]
+      
+      if not all(key in skills_mapping for key in required_keys):
+          missing = [key for key in required_keys if key not in skills_mapping]
+          raise ValueError(f"Missing required keys in skills mapping: {missing}")
+      
+      # Additional validation can be added here
+
+  def extract_header_from_resume(self, resume: str) -> str:
+      """Extract header information from the original resume."""
+      # Simple implementation - in practice, you might want a more sophisticated approach
+      lines = resume.strip().split("\n")
+      # Take the first few non-empty lines as the header
+      header_lines = []
+      for line in lines[:10]:  # Arbitrarily choose first 10 lines to search
+          if line.strip():
+              header_lines.append(line)
+          if len(header_lines) >= 4:  # Assume header is no more than 4 lines
+              break
+      return "\n".join(header_lines)
+
+  # Stage 1A: Job Analysis Implementation
+  def create_job_analysis_prompt(self, job_description: str) -> tuple[str, str]:
+      """Create the prompt for job requirements analysis."""
+      system_prompt = """
+      You are an objective job requirements analyzer. Your task is to extract and categorize the specific skills,
+      experiences, and qualifications required in a job description WITHOUT any reference to any candidate.
+      
+      ## INSTRUCTIONS:
+      
+      1. Analyze ONLY the job description provided.
+      2. Extract and categorize all requirements and preferences.
+      3. DO NOT consider any candidate information - this is a pure job analysis task.
+      
+      ## OUTPUT FORMAT:
+      
+      ```json
+      {
+        "job_requirements": {
+          "technical_skills": {
+            "required": ["skill1", "skill2"],
+            "preferred": ["skill1", "skill2"]
+          },
+          "experience_requirements": {
+            "required": ["exp1", "exp2"],
+            "preferred": ["exp1", "exp2"]
+          },
+          "education_requirements": ["req1", "req2"],
+          "soft_skills": ["skill1", "skill2"],
+          "industry_knowledge": ["knowledge1", "knowledge2"],
+          "responsibilities": ["resp1", "resp2"],
+          "company_values": ["value1", "value2"]
+        }
+      }
+      ```
+      
+      Be specific and detailed in your extraction. Break down compound requirements into individual components.
+      For example, "5+ years experience with React, Node.js and MongoDB" should be separated into:
+      - Experience: "5+ years software development"
+      - Technical skills: "React", "Node.js", "MongoDB"
+      
+      Avoid vague categorizations and be precise about whether skills are explicitly required or just preferred.
+      """
+      
+      prompt = f"Job Description:\n{job_description}"
+      return system_prompt, prompt
+
+  async def analyze_job_requirements(self, message, job_description: str) -> AsyncGenerator[Message, None]:
+      """Analyze job requirements from job description."""
+      try:
+          system_prompt, prompt = self.create_job_analysis_prompt(job_description)
+          async for message in self.call_llm(message, system_prompt, prompt):
+             if message.status != "done":
+              yield message
+          if message.status == "error":
+             return
+          
+          # Extract JSON from response
+          json_str = self.extract_json_from_text(message.response)
+          job_requirements = json.loads(json_str)
+          
+          self.validate_job_requirements(job_requirements)
+          
+          message.status = "done"
+          message.response = json_str
+          yield message
+          return
+
+      except Exception as e:
+          message.status = "error"
+          message.response = f"Error in job requirements analysis: {str(e)}"
+          logger.error(message.response)
+          logger.error(traceback.format_exc())
+          yield message
+          raise
+
+  # Stage 1B: Candidate Analysis Implementation
+  def create_candidate_analysis_prompt(self, resume: str, context: str) -> tuple[str, str]:
+      """Create the prompt for candidate qualifications analysis."""
+      system_prompt = """
+      You are an objective resume analyzer. Your task is to catalog ALL skills, experiences, and qualifications
+      present in a candidate's materials WITHOUT any reference to any job description.
+      
+      ## INSTRUCTIONS:
+      
+      1. Analyze ONLY the candidate's resume and context provided.
+      2. Create a comprehensive inventory of the candidate's actual qualifications.
+      3. DO NOT consider any job requirements - this is a pure candidate analysis task.
+      4. For each qualification, cite exactly where in the materials it appears.
+      
+      ## OUTPUT FORMAT:
+      
+      ```json
+      {
+        "candidate_qualifications": {
+          "technical_skills": [
+            {
+              "skill": "skill name",
+              "evidence": "exact quote from materials",
+              "source": "resume or context",
+              "expertise_level": "explicit level mentioned or 'unspecified'"
+            }
+          ],
+          "work_experience": [
+            {
+              "role": "job title",
+              "company": "company name",
+              "duration": "time period",
+              "responsibilities": ["resp1", "resp2"],
+              "technologies_used": ["tech1", "tech2"],
+              "achievements": ["achievement1", "achievement2"]
+            }
+          ],
+          "education": [
+            {
+              "degree": "degree name",
+              "institution": "institution name",
+              "completed": true/false,
+              "evidence": "exact quote from materials"
+            }
+          ],
+          "projects": [
+            {
+              "name": "project name",
+              "description": "brief description",
+              "technologies_used": ["tech1", "tech2"],
+              "evidence": "exact quote from materials"
+            }
+          ],
+          "soft_skills": [
+            {
+              "skill": "skill name",
+              "evidence": "exact quote or inference basis",
+              "source": "resume or context"
+            }
+          ]
+        }
+      }
+      ```
+      
+      Be thorough and precise. Include ONLY skills and experiences explicitly mentioned in the materials.
+      For each entry, provide the exact text evidence from the materials that supports its inclusion.
+      Do not make assumptions about skills based on job titles or project names - only include skills explicitly mentioned.
+      """
+      
+      prompt = f"Resume:\n{resume}\n\nAdditional Context:\n{context}"
+      return system_prompt, prompt
+
+  async def call_llm(self, message: Message, system_prompt, prompt, temperature=0.7):
+    messages : List[LLMMessage] = [
+      LLMMessage(role="system", content=system_prompt),
+      LLMMessage(role="user", content=prompt)
+    ]
+    message.metadata["options"]={
+        "seed": 8911,
+        "num_ctx": self.context_size,
+        "temperature": temperature # Higher temperature to encourage tool usage
+    }
+
+    message.status = "streaming"
+    yield message
+
+    message.response = ""
+    for response in self.llm.chat(
+        model=self.model, 
+        messages=messages, 
+        options={
+            **message.metadata["options"],
+        },
+        stream=True,
+    ):
+        if not response:
+            message.status = "error"
+            message.response = "No response from LLM."
+            yield message
+            return
+
+        message.status = "streaming"
+        message.response += response.message.content
+
+        if not response.done:
+            yield message
+
+        if response.done:
+            message.metadata["eval_count"] += response.eval_count
+            message.metadata["eval_duration"] += response.eval_duration
+            message.metadata["prompt_eval_count"] += response.prompt_eval_count
+            message.metadata["prompt_eval_duration"] += response.prompt_eval_duration
+            self.context_tokens = response.prompt_eval_count + response.eval_count
+            message.status = "done"
+            yield message
+
+  async def analyze_candidate_qualifications(self, message: Message, resume: str, context: str) -> AsyncGenerator[Message, None]:
+      """Analyze candidate qualifications from resume and context."""
+      try:
+          system_prompt, prompt = self.create_candidate_analysis_prompt(resume, context)
+          async for message in self.call_llm(message, system_prompt, prompt):
+            if message.status != "done":
+               yield message
+          if message.status == "error":
+             return
+          
+          # Extract JSON from response
+          json_str = self.extract_json_from_text(message.response)
+          candidate_qualifications = json.loads(json_str)
+          
+          # Validate structure
+          self.validate_candidate_qualifications(candidate_qualifications)
+          message.status = "done"
+          message.response = json.dumps(candidate_qualifications)
+          return
+      
+      except Exception as e:
+          message.status = "error"
+          message.response = f"Error in candidate qualifications analysis: {str(e)}"
+          logger.error(message.response)
+          logger.error(traceback.format_exc())
+          yield message
+          raise
+
+  # Stage 1C: Mapping Analysis Implementation
+  def create_mapping_analysis_prompt(self ,job_requirements: Dict, candidate_qualifications: Dict) -> tuple[str, str]:
+      """Create the prompt for mapping analysis."""
+      system_prompt = """
+      You are an objective skills mapper. Your task is to identify legitimate matches between job requirements
+      and candidate qualifications WITHOUT fabricating or stretching the truth.
+      
+      ## INSTRUCTIONS:
+      
+      1. Use ONLY the structured job requirements and candidate qualifications provided.
+      2. Create a mapping that shows where the candidate's actual skills and experiences align with job requirements.
+      3. Identify gaps where the candidate lacks required qualifications.
+      4. Suggest legitimate transferable skills ONLY when there is reasonable evidence.
+      
+      ## OUTPUT FORMAT:
+      
+      ```json
+      {
+        "skills_mapping": {
+          "direct_matches": [
+            {
+              "job_requirement": "required skill",
+              "candidate_qualification": "matching skill",
+              "evidence": "exact quote from candidate materials"
+            }
+          ],
+          "transferable_skills": [
+            {
+              "job_requirement": "required skill",
+              "candidate_qualification": "transferable skill",
+              "reasoning": "explanation of legitimate transferability",
+              "evidence": "exact quote from candidate materials"
+            }
+          ],
+          "gap_analysis": {
+            "missing_required_skills": ["skill1", "skill2"],
+            "missing_preferred_skills": ["skill1", "skill2"],
+            "missing_experience": ["exp1", "exp2"]
+          }
+        },
+        "resume_recommendations": {
+          "highlight_points": [
+            {
+              "qualification": "candidate's qualification",
+              "relevance": "why this is highly relevant to the job"
+            }
+          ],
+          "transferable_narratives": [
+            {
+              "from": "candidate's actual experience",
+              "to": "job requirement",
+              "suggested_framing": "how to honestly present the transfer"
+            }
+          ],
+          "honest_limitations": [
+            "frank assessment of major qualification gaps"
+          ]
+        }
+      }
+      ```
+      
+      CRITICAL RULES:
+      1. A "direct match" requires the EXACT SAME skill in both job requirements and candidate qualifications
+      2. A "transferable skill" must have legitimate, defensible connection - do not stretch credibility
+      3. All "missing_required_skills" MUST be acknowledged - do not ignore major gaps
+      4. Every match or transfer claim must cite specific evidence from the candidate materials
+      5. Be conservative in claiming transferability - when in doubt, list as missing
+      """
+      
+      prompt = f"Job Requirements:\n{json.dumps(job_requirements, indent=2)}\n\n"
+      prompt += f"Candidate Qualifications:\n{json.dumps(candidate_qualifications, indent=2)}"
+      return system_prompt, prompt
+
+  async def create_skills_mapping(self, message, job_requirements: Dict, candidate_qualifications: Dict) -> AsyncGenerator[Message, None]:
+      """Create mapping between job requirements and candidate qualifications."""
+      try:
+          system_prompt, prompt = self.create_mapping_analysis_prompt(job_requirements, candidate_qualifications)
+          async for message in self.call_llm(message, system_prompt, prompt):
+             if message != "done":
+                yield message
+          if message.status == "error":
+             return
+          
+          # Extract JSON from response
+          json_str = self.extract_json_from_text(message.response)
+          skills_mapping = json.loads(json_str)
+          
+          # Validate structure
+          self.validate_skills_mapping(skills_mapping)
+          
+          message.status = "done"
+          message.response = json_str
+          yield message
+          return
+      
+      except Exception as e:
+          message.status = "error"
+          message.response = f"Error in skills mapping analysis: {str(e)}"
+          logger.error(message.response)
+          logger.error(traceback.format_exc())
+          yield message
+          raise
+
+  # Stage 2: Resume Generation Implementation
+  def create_resume_generation_prompt(self, skills_mapping: Dict, candidate_qualifications: Dict, original_header: str) -> tuple[str, str]:
+      """Create the prompt for resume generation."""
+      system_prompt = """
+      You are a professional resume writer whose primary concern is FACTUAL ACCURACY. Your task is to create
+      a tailored resume that presents the candidate's actual qualifications in the most relevant way for this job,
+      using ONLY information that has been verified in the skills mapping.
+      
+      ## INSTRUCTIONS:
+      
+      1. Use ONLY the information provided in the skills mapping JSON
+      2. Each skill, experience, or achievement you include MUST appear in either "direct_matches" or "transferable_skills"
+      3. DO NOT include skills listed in "missing_required_skills" or "missing_preferred_skills"
+      4. Format a professional resume with these sections:
+        - Header with name and contact information (exactly as provided in original resume)
+        - Professional Summary (focused on verified matching and transferable skills)
+        - Skills (ONLY from "direct_matches" and "transferable_skills" sections)
+        - Professional Experience (highlighting experiences referenced in the mapping)
+        - Education (exactly as listed in the candidate qualifications)
+      
+      5. Follow these principles:
+        - Use the exact wording from "highlight_points" and "transferable_narratives" when describing experiences
+        - Maintain original job titles, companies, and dates exactly as provided
+        - Use achievement-oriented language that emphasizes results and impact
+        - Prioritize experiences that directly relate to the job requirements
+      
+      ## EVIDENCE REQUIREMENT:
+      
+      For each skill or qualification you include in the resume, you MUST be able to trace it to:
+      1. A specific entry in "direct_matches" or "transferable_skills", AND
+      2. The original evidence citation in the candidate qualifications
+      
+      If you cannot meet both these requirements for any content, DO NOT include it.
+      
+      ## FORMAT REQUIREMENTS:
+      
+      - Create a clean, professional resume format
+      - Use consistent formatting for similar elements
+      - Ensure readability with appropriate white space
+      - Use bullet points for skills and achievements
+      - Include a final note: "Note: Initial draft of the resume was generated using the Backstory application written by James Ketrenos."
+      
+      ## FINAL VERIFICATION:
+      
+      Before completing the resume:
+      1. Check that EVERY skill listed appears in either "direct_matches" or "transferable_skills"
+      2. Verify that no skills from "missing_required_skills" are included
+      3. Ensure all experience descriptions can be traced to evidence in candidate qualifications
+      4. Confirm that transferable skills are presented honestly without exaggeration
+      """
+      
+      prompt = f"Skills Mapping:\n{json.dumps(skills_mapping, indent=2)}\n\n"
+      prompt += f"Candidate Qualifications:\n{json.dumps(candidate_qualifications, indent=2)}\n\n"
+      prompt += f"Original Resume Header:\n{original_header}"
+      return system_prompt, prompt
+
+  async def generate_tailored_resume(self, message, skills_mapping: Dict, candidate_qualifications: Dict, original_header: str) -> AsyncGenerator[Message, None]:
+      """Generate a tailored resume based on skills mapping."""
+      try:
+          system_prompt, prompt = self.create_resume_generation_prompt(skills_mapping, candidate_qualifications, original_header)
+          async for message in self.call_llm(message, system_prompt, prompt, temperature=0.4):  # Slightly higher temperature for better writing
+            if message.status != "done":
+              yield message
+          if message.status == "error":
+             return
+          message.status = "done"
+          yield message
+          return
+      
+      except Exception as e:
+          message.status = "error"
+          message.response = f"Error in resume generation: {str(e)}"
+          logger.error(message.response)
+          logger.error(traceback.format_exc())
+          yield message
+          raise
+      
+
+  # Stage 3: Verification Implementation
+  def create_verification_prompt(self, generated_resume: str, skills_mapping: Dict, candidate_qualifications: Dict) -> tuple[str, str]:
+      """Create the prompt for resume verification."""
+      system_prompt = """
+      You are a critical resume fact-checker responsible for verifying the accuracy of a tailored resume.
+      Your task is to identify and flag any fabricated or embellished information that does not appear in
+      the candidate's original materials.
+      
+      ## INSTRUCTIONS:
+      
+      1. Compare the tailored resume against:
+        - The structured skills mapping
+        - The candidate's original qualifications
+        
+      2. Perform a line-by-line verification focusing on:
+        - Skills claimed vs. skills verified in original materials
+        - Experience descriptions vs. actual documented experience
+        - Projects and achievements vs. documented accomplishments
+        - Technical knowledge claims vs. verified technical background
+      
+      3. Create a verification report with these sections:
+      
+      ## OUTPUT FORMAT:
+      
+      ```json
+      {
+        "verification_results": {
+          "factual_accuracy": {
+            "status": "PASS/FAIL",
+            "issues": [
+              {
+                "claim": "The specific claim in the resume",
+                "issue": "Why this is problematic",
+                "source_check": "Result of checking against source materials",
+                "suggested_correction": "How to fix this issue"
+              }
+            ]
+          },
+          "skill_verification": {
+            "status": "PASS/FAIL",
+            "unverified_skills": ["skill1", "skill2"]
+          },
+          "experience_verification": {
+            "status": "PASS/FAIL",
+            "problematic_statements": [
+              {
+                "statement": "The problematic experience statement",
+                "issue": "Why this is problematic",
+                "suggested_correction": "How to fix this issue"
+              }
+            ]
+          },
+          "overall_assessment": "APPROVED/NEEDS REVISION",
+          "correction_instructions": "Specific instructions for correcting the resume"
+        }
+      }
+      ```
+      
+      ## CRITICAL VERIFICATION CRITERIA:
+      
+      1. Any skill mentioned in the resume MUST appear verbatim in the skills mapping
+      2. Any technology experience claimed MUST be explicitly documented in original materials
+      3. Role descriptions must not imply expertise with technologies not listed in original materials
+      4. "Transferable skills" must be reasonably transferable, not stretches or fabrications
+      5. Job titles, dates, and companies must match exactly with original materials
+      6. Professional summary must not imply experience with technologies from the job description that aren't in the candidate's background
+      
+      ## SPECIAL ATTENTION:
+      
+      Pay particular attention to subtle fabrications such as:
+      - Vague wording that implies experience ("worked with", "familiar with", "utilized") with technologies not in original materials
+      - Reframing unrelated experience to falsely imply relevance to the job requirements
+      - Adding technologies to project descriptions that weren't mentioned in the original materials
+      - Exaggerating level of involvement or responsibility in projects or roles
+      - Creating achievements that weren't documented in the original materials
+      """
+      
+      prompt = f"Tailored Resume:\n{generated_resume}\n\n"
+      prompt += f"Skills Mapping:\n{json.dumps(skills_mapping, indent=2)}\n\n"
+      prompt += f"Candidate Qualifications:\n{json.dumps(candidate_qualifications, indent=2)}"
+      return system_prompt, prompt
+
+  async def verify_resume(self, message: Message, generated_resume: str, skills_mapping: Dict, candidate_qualifications: Dict) -> AsyncGenerator[Message, None]:
+      """Verify the generated resume for accuracy against original materials."""
+      try:
+          system_prompt, prompt = self.create_verification_prompt(generated_resume, skills_mapping, candidate_qualifications)
+          async for message in self.call_llm(message, system_prompt, prompt):
+            if message.status != "done":
+              yield message
+          
+          # Extract JSON from response
+          json_str = self.extract_json_from_text(message.response)
+          verification_results = json.loads(json_str)
+          
+          message.status = "done"
+          message.response = json_str
+          yield message
+          return
+      except Exception as e:
+          message.status = "error"
+          message.response = f"Error in resume verification: {str(e)}"
+          logger.error(message.response)
+          logger.error(traceback.format_exc())
+          yield message
+          raise
+
+  async def correct_resume_issues(self, message: Message, generated_resume: str, verification_results: Dict, skills_mapping: Dict, candidate_qualifications: Dict, original_header: str)  -> AsyncGenerator[Message, None]:
+      """Correct issues in the resume based on verification results."""
+      if verification_results["verification_results"]["overall_assessment"] == "APPROVED":
+          message.status = "done"
+          message.status = generated_resume
+          yield message
+          return
+      
+      system_prompt = """
+      You are a professional resume editor with a focus on factual accuracy. Your task is to correct
+      the identified issues in a tailored resume according to the verification report.
+      
+      ## INSTRUCTIONS:
+      
+      1. Make ONLY the changes specified in the verification report
+      2. Ensure all corrections maintain factual accuracy based on the skills mapping
+      3. Do not introduce any new claims or skills not present in the verification data
+      4. Maintain the original format and structure of the resume
+      
+      ## PROCESS:
+      
+      1. For each issue in the verification report:
+        - Identify the problematic text in the resume
+        - Replace it with the suggested correction
+        - Ensure the correction is consistent with the rest of the resume
+      
+      2. After making all corrections:
+        - Review the revised resume for consistency
+        - Ensure no factual inaccuracies have been introduced
+        - Check that all formatting remains professional
+      
+      Return the fully corrected resume.
+      """
+      
+      prompt = f"Original Resume:\n{generated_resume}\n\n"
+      prompt += f"Verification Results:\n{json.dumps(verification_results, indent=2)}\n\n"
+      prompt += f"Skills Mapping:\n{json.dumps(skills_mapping, indent=2)}\n\n"
+      prompt += f"Candidate Qualifications:\n{json.dumps(candidate_qualifications, indent=2)}\n\n"
+      prompt += f"Original Resume Header:\n{original_header}"
+      
+      try:
+          async for message in self.call_llm(message, prompt, system_prompt, temperature=0.3):
+            if message.status != "done":
+              yield message
+          yield message
+          if message.status == "error":
+             return
+
+      except Exception as e:
+          message.status = "error"
+          message.response = f"Error in resume correction: {str(e)}"
+          logger.error(message.response)
+          logger.error(traceback.format_exc())
+          yield message
+          raise
+
+  async def generate_factual_tailored_resume(self, message: Message, job_description: str, resume: str, additional_context: str = "") -> AsyncGenerator[Message, None]:
+      """
+      Main function to generate a factually accurate tailored resume.
+      
+      Args:
+          job_description: The job description text
+          resume: The candidate's original resume text
+          additional_context: Any additional context about the candidate (optional)
+          
+      Returns:
+          Dict containing the generated resume and supporting analysis
+      """
+      try:
+          message.status = "thinking"
+          message.response = "Starting multi-stage RAG resume generation process"
+          logger.info(message.response)
+          yield message
+
+          # Stage 1A: Analyze job requirements
+          message.response = "Stage 1A: Analyzing job requirements"
+          logger.info(message.response)
+          yield message
+
+          async for message in self.analyze_job_requirements(message, job_description):
+            if message.status != "done":
+              yield message
+          if message.status == "error":
+            return
+
+          job_requirements = json.loads(message.response)
+
+          # Stage 1B: Analyze candidate qualifications
+          message.status = "thinking"
+          message.response = "Stage 1B: Analyzing candidate qualifications"
+          logger.info(message.response)
+          yield message
+
+          async for message in self.analyze_candidate_qualifications(message, resume, additional_context):
+            if message.status != "done":
+              yield message
+          if message.status == "error":
+             return
+
+          candidate_qualifications = json.loads(message.response)
+          
+          # Stage 1C: Create skills mapping
+          message.status = "thinking"
+          message.response = "Stage 1C: Creating skills mapping"
+          logger.info(message.response)
+          yield message
+
+          async for message in self.create_skills_mapping(message, job_requirements, candidate_qualifications):
+            if message.status != "done":
+              yield message
+          if message.status == "error":
+             return
+            
+          skills_mapping = json.loads(message.response)
+          
+          # Extract header from original resume
+          original_header = self.extract_header_from_resume(resume)
+          
+          # Stage 2: Generate tailored resume
+          message.status = "thinking"
+          message.response = "Stage 2: Generating tailored resume"
+          logger.info(message.response)
+          yield message
+
+          async for message in self.generate_tailored_resume(message, skills_mapping, candidate_qualifications, original_header):
+            if message.status != "done":
+              yield message
+          if message.status == "error":
+             return
+
+          generated_resume = message.response
+
+          # Stage 3: Verify resume
+          message.status = "thinking"
+          message.response = "Stage 3: Verifying resume for accuracy"
+          logger.info(message.response)
+          yield message
+
+          async for message in self.verify_resume(message, generated_resume, skills_mapping, candidate_qualifications):
+            if message.status != "done":
+              yield message
+          if message.status == "error":
+             return
+          
+          verification_results = json.loads(message.response)
+          
+          # Handle corrections if needed
+          if verification_results["verification_results"]["overall_assessment"] == "NEEDS REVISION":
+              message.status = "thinking"
+              message.response = "Correcting issues found in verification"
+              logger.info(message.response)
+              yield message
+
+              async for message in self.correct_resume_issues(
+                message=message,
+                generated_resume=generated_resume, 
+                verification_results=verification_results, 
+                skills_mapping=skills_mapping, 
+                candidate_qualifications=candidate_qualifications,
+                original_header=original_header
+              ):
+                if message.status != "done":
+                  yield message
+              if message.status == "error":
+                return
+
+              generated_resume = message.response
+              
+              # Re-verify after corrections
+              message.status = "thinking"
+              message.response = "Re-verifying corrected resume"
+              logger.info(message.response)
+              async for message in self.verify_resume(
+                  message=message, 
+                  generated_resume=generated_resume, 
+                  skills_mapping=skills_mapping, 
+                  candidate_qualifications=candidate_qualifications):
+                if message.status != "done":
+                   yield message
+              if message.status == "error":
+                 return
+                 
+          # Return the final results
+          message.status = "done"
+          message.response = json.dumps({
+              "job_requirements": job_requirements,
+              "candidate_qualifications": candidate_qualifications,
+              "skills_mapping": skills_mapping,
+              "generated_resume": generated_resume,
+              "verification_results": verification_results
+          })
+          yield message
+
+          logger.info("Resume generation process completed successfully")
+          return
+          
+      except Exception as e:
+          message.status = "error"
+          logger.info(message.response)
+          message.response = f"Error in resume generation process: {str(e)}"
+          logger.error(message.response)
+          logger.error(traceback.format_exc())
+          yield message
+          raise
+
+  # Main orchestration function
+  async def generate_llm_response(self, llm: Any, model: str, message: Message, temperature=0.7) -> AsyncGenerator[Message, None]:
+    logger.info(f"{self.agent_type} - {inspect.stack()[0].function}")
+    
+    self.llm = llm
+    self.model = model
+
+    self.metrics.generate_count.labels(agent=self.agent_type).inc()
+    with self.metrics.generate_duration.labels(agent=self.agent_type).time():
+        job_description = "You write C and C++ code for 4 years."
+        resume = "I have worked on Cobol and QuickBasic for 18 years."
+        additional_context = ""
+
+        async for message in self.generate_factual_tailored_resume(message=message, job_description=job_description, resume=resume, additional_context=additional_context):
+           if message.status != "done":
+            yield message
+        
+        yield message
+        return
+
 # Register the base agent
 agent_registry.register(JobDescription._agent_type, JobDescription)