1. Observe environment → Update Beliefs
2. Generate Options (potential desires) based on Beliefs and Events
3. Filter Options → Select Desires (what to pursue)
4. Plan → Generate Intentions (how to achieve desires)
5. Execute → Perform next action from Intention
6. Repeat

function updateBeliefs(currentBeliefs, newPercepts):
    for each percept in newPercepts:
        if percept contradicts currentBeliefs:
            # Use belief revision logic (AGM postulates)
            resolveContradiction(currentBeliefs, percept)
        else:
            add percept to currentBeliefs
    # Infer logical consequences
    return deductiveClosure(currentBeliefs)

function generateOptions(beliefs, events):
    options = []
    for each event in events:
        relevantPlans = getPlansThatHandle(event, beliefs)
        for each plan in relevantPlans:
            if checkContext(plan.context, beliefs):
                options.append(plan.goal)
    return options

function deliberate(beliefs, desires, intentions):
    # Filter desires based on consistency and priorities
    validDesires = filter(desires, beliefs, intentions)
    selectedDesires = prioritize(validDesires)
    
    newIntentions = []
    for each desire in selectedDesires:
        plan = meansEndsReasoning(desire, beliefs)
        if plan is not empty:
            newIntentions.append(createIntention(desire, plan))
    
    return newIntentions

function meansEndsReasoning(goal, beliefs):
    # Find or construct a plan to achieve the goal
    existingPlan = planLibrary.find(goal, beliefs)
    if existingPlan:
        return instantiate(existingPlan, beliefs)
    else:
        return planFromScratch(goal, beliefs) # Use planner

Plan Template:
    Goal: what this plan achieves
    Context: preconditions (beliefs required)
    Body: sequence of actions/subgoals
    Failure handling: what to do if plan fails

from typing import Set, List, Optional
from dataclasses import dataclass

@dataclass
class Belief:
    predicate: str
    args: tuple
    
@dataclass
class Desire:
    goal: str
    priority: int

@dataclass  
class Intention:
    desire: Desire
    plan: List[str]  # Action sequence
    current_step: int = 0

class BDIAgent:
    def __init__(self):
        self.beliefs: Set[Belief] = set()
        self.desires: List[Desire] = []
        self.intentions: List[Intention] = []
        self.plan_library = {}  # goal -> list of plans
        
    def perceive(self, percepts: List[Belief]):
        """Update beliefs based on observations"""
        # Belief revision: add new percepts, remove contradictions
        for percept in percepts:
            # Remove contradicting beliefs
            self.beliefs = {b for b in self.beliefs 
                           if not self._contradicts(b, percept)}
            self.beliefs.add(percept)
    
    def deliberate(self):
        """Select desires to pursue"""
        # Generate options from current context
        options = self._generate_options()
        
        # Filter based on consistency and resources
        valid_desires = self._filter_desires(options)
        
        # Prioritize (e.g., by utility, urgency)
        self.desires = sorted(valid_desires, 
                            key=lambda d: d.priority, 
                            reverse=True)
    
    def plan(self):
        """Create intentions from desires"""
        for desire in self.desires:
            if not self._has_intention_for(desire):
                plan = self._find_plan(desire)
                if plan:
                    self.intentions.append(
                        Intention(desire=desire, plan=plan)
                    )
    
    def execute(self):
        """Execute next step of current intention"""
        if not self.intentions:
            return None
            
        # Execute highest priority intention
        intention = self.intentions[0]
        
        if intention.current_step >= len(intention.plan):
            # Plan completed
            self.intentions.pop(0)
            self.desires.remove(intention.desire)
            return None
        
        action = intention.plan[intention.current_step]
        intention.current_step += 1
        
        return action
    
    def run_cycle(self, percepts: List[Belief]):
        """One BDI reasoning cycle"""
        self.perceive(percepts)
        self.deliberate()
        self.plan()
        action = self.execute()
        return action
    
    def _find_plan(self, desire: Desire) -> Optional[List[str]]:
        """Find a plan from library that achieves the goal"""
        plans = self.plan_library.get(desire.goal, [])
        for plan_template in plans:
            if self._check_context(plan_template['context']):
                return plan_template['actions']
        return None
    
    def _check_context(self, context: List[Belief]) -> bool:
        """Check if all context conditions are in beliefs"""
        return all(c in self.beliefs for c in context)
    
    def _generate_options(self) -> List[Desire]:
        # Simplified: could use rules or event handlers
        return []
    
    def _filter_desires(self, options: List[Desire]) -> List[Desire]:
        # Filter based on consistency, resources, etc.
        return options
    
    def _has_intention_for(self, desire: Desire) -> bool:
        return any(i.desire.goal == desire.goal 
                  for i in self.intentions)
    
    def _contradicts(self, b1: Belief, b2: Belief) -> bool:
        # Simplified: check if same predicate with different truth value
        return b1.predicate == f"not_{b2.predicate}" or \
               b2.predicate == f"not_{b1.predicate}"

# Example usage
agent = BDIAgent()

# Define a plan library
agent.plan_library = {
    "get_coffee": [
        {
            'context': [Belief("location", ("kitchen",))],
            'actions': ["open_cupboard", "grab_mug", "pour_coffee"]
        },
        {
            'context': [Belief("location", ("cafe",))],
            'actions': ["wait_in_line", "order_coffee", "pay"]
        }
    ]
}

# Run a cycle
percepts = [Belief("location", ("kitchen",))]
agent.desires = [Desire(goal="get_coffee", priority=10)]

action = agent.run_cycle(percepts)
print(f"Action: {action}")  # Output: Action: open_cupboard

from langgraph.graph import StateGraph
from typing import TypedDict

class AgentState(TypedDict):
    beliefs: dict
    desires: list
    intentions: list
    current_action: str

def perceive_node(state: AgentState) -> AgentState:
    # LLM extracts beliefs from observations
    observations = get_environment_state()
    new_beliefs = llm.extract_beliefs(observations)
    state['beliefs'].update(new_beliefs)
    return state

def deliberate_node(state: AgentState) -> AgentState:
    # LLM generates and prioritizes desires
    prompt = f"Given beliefs: {state['beliefs']}, what goals should we pursue?"
    desires = llm.generate_desires(prompt)
    state['desires'] = desires
    return state

def plan_node(state: AgentState) -> AgentState:
    # LLM creates plans for desires
    for desire in state['desires']:
        plan = llm.create_plan(desire, state['beliefs'])
        state['intentions'].append({'desire': desire, 'plan': plan})
    return state

def execute_node(state: AgentState) -> AgentState:
    # Execute next action from intention
    if state['intentions']:
        intention = state['intentions'][0]
        action = intention['plan'].pop(0)
        state['current_action'] = action
        if not intention['plan']:
            state['intentions'].pop(0)
    return state

# Build graph
workflow = StateGraph(AgentState)
workflow.add_node("perceive", perceive_node)
workflow.add_node("deliberate", deliberate_node)
workflow.add_node("plan", plan_node)
workflow.add_node("execute", execute_node)

workflow.set_entry_point("perceive")
workflow.add_edge("perceive", "deliberate")
workflow.add_edge("deliberate", "plan")
workflow.add_edge("plan", "execute")
workflow.add_edge("execute", "perceive")  # Loop back

app = workflow.compile()

class ShoppingAgent(BDIAgent):
    def __init__(self):
        super().__init__()
        self.plan_library = {
            "buy_item": [
                # Add plans here
            ],
            "minimize_cost": [
                # Add plans here
            ]
        }
    
    # Implement custom option generation
    def _generate_options(self):
        # Generate desires based on beliefs
        # e.g., if "low_milk" in beliefs, add desire "buy_milk"
        pass

# Test scenarios:
# 1. Agent at home, believes milk is low → should form intention to buy milk
# 2. Agent at store, sees milk is expensive → might decide to skip or go to another store
# 3. Agent acquires new belief that bread is also needed → should add to intentions