Use Cases

class CareerAI {
  async provideAdvice(userQuestion, userProfile) {
    // AI provides initial guidance
    const aiGuidance = await this.llm.generate({
      prompt: userQuestion,
      context: userProfile
    });
    
    // Assess if human expertise needed
    const needsHuman = this.assessComplexity(userQuestion);
    
    if (needsHuman) {
      // Seamlessly integrate human career expert
      const humanMentor = await myweave.chat({
        message: `${userQuestion}\n\nAI's initial thoughts: ${aiGuidance}`,
        context: {
          coachId: "career_expert_123",
          mode: "career_consulting",
          userId: userProfile.id,
          isAuthenticated: true
        }
      });
      
      // AI synthesizes final advice
      return {
        advice: this.synthesize(aiGuidance, humanMentor),
        sources: ["AI Analysis", "Human Career Expert"],
        confidence: "high"
      };
    }
    
    return aiGuidance;
  }
}

// AI coding assistant with human expertise
async function reviewArchitecture(codebase) {
  // Step 1: AI analyzes code
  const aiAnalysis = await llm.analyzeCode(codebase);
  
  // Step 2: Upload to expert's knowledge base
  await myweave.uploadKnowledge({
    coachId: "senior_architect_456",
    files: codebase.files
  });
  
  // Step 3: Expert review via chat
  const expertReview = await myweave.chat({
    message: `Please review this architecture. AI found: ${aiAnalysis.issues}`,
    context: {
      coachId: "senior_architect_456",
      mode: "code_review"
    }
  });
  
  // Step 4: AI formats actionable recommendations
  return formatRecommendations(expertReview);
}

class HybridSupportAI:
    async def handle_customer_inquiry(self, inquiry):
        # AI attempts to help
        ai_solution = await self.llm.solve(inquiry)
        confidence = self.assess_confidence(ai_solution)
        
        # Automatically escalate complex issues
        if confidence < 0.7 or inquiry.sentiment == "frustrated":
            # Bring in human support expert
            expert_thread = await myweave.start_consultation(
                coach_id="support_expert_789",
                context={
                    "customer_issue": inquiry.text,
                    "ai_attempt": ai_solution,
                    "customer_history": inquiry.history
                }
            )
            
            return {
                "response": expert_thread,
                "handled_by": "human_expert",
                "escalation_reason": "complexity" if confidence < 0.7 else "customer_sentiment"
            }
        
        return {
            "response": ai_solution,
            "handled_by": "ai",
            "confidence": confidence
        }

class AdaptiveLearningAI {
  async teachConcept(studentQuestion, learningHistory) {
    // AI provides initial explanation
    const aiTeaching = await this.llm.teach({
      question: studentQuestion,
      studentLevel: learningHistory.level
    });
    
    // Check if student is struggling
    const isStruggling = this.detectStruggle(learningHistory);
    
    if (isStruggling || studentQuestion.includes("still don't understand")) {
      // Connect to human master teacher
      const masterTeacher = await myweave.chat({
        message: `Student is struggling with: ${studentQuestion}\nAI attempted: ${aiTeaching}`,
        context: {
          coachId: "master_teacher_physics_101",
          mode: "tutoring",
          courseId: learningHistory.courseId
        }
      });
      
      return {
        explanation: masterTeacher,
        source: "Master Teacher",
        followUp: true // Schedule more 1-on-1 time
      };
    }
    
    return {
      explanation: aiTeaching,
      source: "AI Tutor"
    };
  }
}

async function developBusinessStrategy(businessContext, financials) {
  // Step 1: AI analyzes data
  const aiInsights = await llm.analyzeFinancials(financials);
  const aiOptions = await llm.generateStrategicOptions(businessContext);
  
  // Step 2: Human consultant validates and refines
  const consultantReview = await myweave.chat({
    message: `Business context: ${businessContext}\n
              AI analysis: ${aiInsights}\n
              AI strategic options: ${aiOptions}\n
              Please provide strategic guidance.`,
    context: {
      coachId: "mba_consultant_456",
      mode: "strategic_consulting"
    },
    action: "create_framework" // Use SWOT or other framework
  });
  
  // Step 3: AI creates final strategic plan
  const finalStrategy = await llm.createPlan({
    aiAnalysis: aiInsights,
    consultantGuidance: consultantReview,
    constraints: businessContext.constraints
  });
  
  return {
    strategy: finalStrategy,
    validated: true,
    confidence: "high",
    sources: ["AI Data Analysis", "MBA Consultant", "AI Synthesis"]
  };
}

async function provideMentalHealthSupport(userMessage, sessionHistory) {
  // AI provides emotional support
  const aiSupport = await wellnessAI.respond(userMessage, sessionHistory);
  
  // Assess risk and need for human intervention
  const riskAssessment = await assessMentalHealthRisk(userMessage, sessionHistory);
  
  if (riskAssessment.level === "high" || userMessage.includes("talk to therapist")) {
    // Seamlessly connect to licensed therapist
    const therapistSession = await myweave.chat({
      message: `Session context: ${sessionHistory}\nCurrent concern: ${userMessage}`,
      context: {
        coachId: "licensed_therapist_101",
        mode: "therapy_session",
        userId: user.id,
        isAuthenticated: true
      }
    });
    
    return {
      response: therapistSession,
      provider: "licensed_therapist",
      type: "human_professional",
      urgent: riskAssessment.level === "high"
    };
  }
  
  return {
    response: aiSupport,
    provider: "ai_wellness",
    type: "supportive_ai"
  };
}

if (aiConfidence < threshold) {
  // Call human expert
  return await myweave.consult(humanExpert);
}

const complexity = assessComplexity(userRequest);

if (complexity === "high") {
  return await myweave.consult(domainExpert);
} else {
  return await ai.respond(userRequest);
}

const aiDraft = await ai.generate(task);
const humanRefinement = await myweave.review(aiDraft);
const final = await ai.synthesize([aiDraft, humanRefinement]);

if (user.preferences.expertMode === "human") {
  return await myweave.consult(expert);
} else {
  return await ai.respond(query);
}