AI Task Inference

@app.post("/api/start-job", response_model=StartJobResponse)
async def start_job(request: StartJobRequest):
    """
    Start a new job request.
    
    Flow:
    1. Call Grok LLM to infer the task type
    2. Generate up to 5 clarifying questions
    3. Create Job object in memory
    4. Return job_id, task, and questions
    """
    try:
        # Step 1: Infer task from query using Grok LLM
        task = await infer_task(request.query)
        
        # Step 2: Generate clarifying questions
        questions_data = await generate_clarifying_questions(
            task=task,
            query=request.query,
            zip_code=request.zip_code,
            date_needed=request.date_needed,
            price_limit=request.price_limit
        )
        
        # Convert to ClarifyingQuestion objects
        questions = [
            ClarifyingQuestion(id=q["id"], question=q["question"])
            for q in questions_data
        ]
        
        # Step 3: Create Job object (in-memory, not DB)
        job_id = str(uuid.uuid4())
        job = Job(
            id=job_id,
            original_query=request.query,
            task=task,
            house_address=request.house_address,
            zip_code=request.zip_code,
            date_needed=request.date_needed,
            price_limit=request.price_limit,
            questions=questions,
            status=JobStatus.COLLECTING_INFO
        )
        
        # Store job in memory
        jobs_store[job_id] = job
        
        return StartJobResponse(
            job_id=job_id,
            task=task,
            questions=questions
        )
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error starting job: {str(e)}")

async def infer_task(query: str) -> str:
    """
    Use Grok LLM to infer the service task from a user query.
    
    Args:
        query: User's free text query (e.g., "fix my toilet")
        
    Returns:
        Inferred task type (e.g., "plumber", "electrician", "cleaner")
    """
    # Use fallback if no API key is configured
    if not XAI_API_KEY:
        print("⚠️  No XAI_API_KEY set - using fallback task inference")
        return _fallback_infer_task(query)
    
    system_prompt = """You are a service task classifier. Given a user's request, 
identify the type of service professional needed. 

Respond with ONLY a single word or short phrase for the service type, such as:
- plumber
- electrician  
- house cleaner
- painter
- handyman
- HVAC technician
- locksmith
- carpenter
- landscaper
- appliance repair
- pest control
- roofer
- moving company
- auto mechanic

Be specific but concise. Just the service type, nothing else."""

    try:
        # Initialize xAI Client
        client = Client(api_key=XAI_API_KEY)
        
        # Create Chat
        chat = client.chat.create(model="grok-3-fast")
        
        # Add messages
        chat.append(system(system_prompt))
        chat.append(user(f"What type of service professional is needed for: {query}"))
        
        # Get response
        full_response = ""
        for response, chunk in chat.stream():
            if chunk.content:
                full_response += chunk.content
        
        task = full_response.strip().lower()
        return task
        
    except Exception as e:
        print(f"Grok API exception: {e}")
        return _fallback_infer_task(query)