Update llm/world_generator.py

llm/world_generator.py

@@ -431,8 +431,12 @@ class DeterministicWorldSpecBuilder:
     """Build a valid generic fallback ``WorldSpec`` without an SLM.
 
     This fallback exists so the Gradio demo can still run when no SLM client is
-    configured or when the model returns invalid JSON. It does not replace the
-    SLM; it provides a safe baseline.
+    configured or when the model returns invalid JSON.
+
+    Unlike the earliest fallback version, this builder preserves important
+    prompt entities when possible. For example, a prompt mentioning sheep,
+    wolves, a hunter, and grass will produce sheep agents, wolf agents, a
+    hunter agent, and grass resources instead of generic farm-support roles.
     """
 
     default_steps: int = 60
@@ -448,56 +452,52 @@ class DeterministicWorldSpecBuilder:
         """Build a deterministic world spec from prompt keywords."""
 
         domain = self._infer_domain(prompt)
+        max_agents = self._max_agents_from_constraints(constraints) or self.max_agents
+        max_agents = max(1, int(max_agents))
+
+        roles = self._roles_for_prompt(prompt, domain, max_agents=max_agents)
+        resources = self._resources_for_prompt(prompt, domain)
         world_id = _slugify(f"{domain}_world")
-        roles = self._roles_for_domain(domain)[: max(1, int(self.max_agents))]
-        resources = self._resources_for_domain(domain)
-        goals = self._goals_for_domain(domain)
 
         agents = tuple(
             self._agent_spec(
                 index=index,
                 role=role,
                 domain=domain,
-                goals=goals,
-                total_agents=len(roles),
+                roles=roles,
             )
             for index, role in enumerate(roles)
         )
 
         resource_specs = tuple(
             ResourceSpec(
-                id=f"{resource_type}_{index + 1}",
+                id=self._resource_id(resource_type, index),
                 type=resource_type,
                 amount=float(10 + index * 4),
                 position=(float(2 + index * 2), float(7 - index % 4)),
-                regeneration_rate=0.1 if index == 0 else 0.0,
+                regeneration_rate=self._resource_regeneration_rate(resource_type),
                 max_amount=float(30 + index * 5),
-                metadata={"domain": domain},
+                metadata={
+                    "domain": domain,
+                    "generated_by": "deterministic_fallback",
+                    "prompt_entity": resource_type in self._prompt_entity_resource_names(prompt),
+                },
             )
             for index, resource_type in enumerate(resources)
         )
 
-        events = (
-            EventSpec(
-                id="midpoint_pressure",
-                name="midpoint_pressure",
-                trigger_step=max(1, self.default_steps // 2),
-                payload={
-                    "description": "A generic pressure event that can be narrated later.",
-                    "domain": domain,
-                },
-                enabled=True,
-                metadata={"generated_by": "fallback_builder"},
-            ),
+        events = self._events_for_prompt(
+            prompt=prompt,
+            domain=domain,
+            roles=roles,
+            resources=resources,
         )
 
-        description = self._description(prompt, domain, constraints)
-
         return WorldSpec(
             schema_version="1.0",
             id=world_id,
             name=_title_from_domain(domain),
-            description=description,
+            description=self._description(prompt, domain, constraints),
             simulation=SimulationSpec(
                 steps=max(1, int(self.default_steps)),
                 seed=self.default_seed,
@@ -524,6 +524,8 @@ class DeterministicWorldSpecBuilder:
                 "generated_by": "deterministic_fallback",
                 "domain": domain,
                 "source_prompt": prompt,
+                "entity_aware_fallback": True,
+                "constraints": constraints if isinstance(constraints, Mapping) else str(constraints or ""),
             },
         )
 
@@ -533,18 +535,13 @@ class DeterministicWorldSpecBuilder:
         index: int,
         role: str,
         domain: str,
-        goals: Sequence[str],
-        total_agents: int,
+        roles: Sequence[str],
     ) -> AgentSpec:
         """Create one generic fallback agent spec."""
 
-        x = 1.0 + (index % 3) * 3.0
-        y = 1.0 + (index // 3) * 3.0
-        agent_id = f"{role}_{index + 1}"
-
-        target_agent_id = None
-        if total_agents > 1:
-            target_agent_id = f"{self._roles_for_domain(domain)[(index + 1) % total_agents]}_{((index + 1) % total_agents) + 1}"
+        agent_id = self._agent_id_for_roles(roles, index)
+        target_agent_id = self._next_agent_id_for_roles(roles, index)
+        goals = self._goals_for_role(role, domain)
 
         goal_records = [
             {
@@ -556,22 +553,49 @@ class DeterministicWorldSpecBuilder:
             for goal_index, goal in enumerate(goals)
         ]
 
+        x, y = self._position_for_index(index)
+        role_state = self._state_for_role(role, domain, index)
+
         behaviors = [
             BehaviorSpec(
-                    name="remember",
-                    params={
-                        "category": "initial_context",
-                        "content": {
-                            "role": role,
-                            "domain": domain,
-                            "note": "Seed memory created by fallback generator.",
-                        },
-                        "tags": ["initial", domain],
+                name="remember",
+                params={
+                    "category": "initial_context",
+                    "content": {
+                        "role": role,
+                        "domain": domain,
+                        "note": f"Seed memory for {role} created by entity-aware fallback generator.",
                     },
-                ),
-            BehaviorSpec(name="evaluate", params={"category": "strategy"}),
-            BehaviorSpec(name="prioritize", params={"source_path": "memory.goals"}),
-            BehaviorSpec(name="choose_goal", params={}),
+                    "tags": ["initial", domain, role],
+                },
+            ),
+            BehaviorSpec(
+                name="evaluate",
+                params={
+                    "category": f"{role}_strategy",
+                    "candidate_options": self._options_for_role(role),
+                    "known_options_path": "memory.known_options",
+                    "adoption_threshold": 0.7,
+                    "write_decision_path": "memory.latest_strategy_decision",
+                },
+            ),
+            BehaviorSpec(
+                name="prioritize",
+                params={
+                    "source_path": "memory.goals",
+                    "item_attribute_weights": {
+                        "importance": 1.0,
+                        "score": 1.0,
+                    },
+                },
+            ),
+            BehaviorSpec(
+                name="choose_goal",
+                params={
+                    "source_path": "memory.latest_priorities.items",
+                    "current_goal_path": "state.current_goal",
+                },
+            ),
             BehaviorSpec(
                 name="communicate",
                 params={
@@ -580,64 +604,549 @@ class DeterministicWorldSpecBuilder:
                     "max_recipients": 1,
                 }
                 if target_agent_id is not None
-                else {"message": f"{role}_status_update", "max_recipients": 1},
+                else {
+                    "message": f"{role}_status_update",
+                    "max_recipients": 1,
+                },
             ),
             BehaviorSpec(
                 name="cooperate",
                 params={
                     "target_agent_id": target_agent_id,
                     "goal": goals[0],
-                    "effort": 1.0,
+                    "effort": self._effort_for_role(role),
                 }
                 if target_agent_id is not None
-                else {"goal": goals[0], "effort": 1.0},
+                else {
+                    "goal": goals[0],
+                    "effort": self._effort_for_role(role),
+                },
+            ),
+            BehaviorSpec(
+                name="update_belief",
+                params={
+                    "belief_id": f"{role}_situation_belief",
+                    "proposition": self._belief_for_role(role),
+                    "evidence_path": self._evidence_path_for_role(role),
+                    "learning_rate": 0.25,
+                    "write_belief_path": "memory.latest_situation_belief",
+                },
             ),
         ]
 
-        policy = PolicySpec(
-            type="rule_policy",
-            params={
-                "selection_strategy": "highest_score",
-                "rules": [
-                    {"behavior_name": "choose_goal", "score_delta": 4.0, "priority_delta": 1.0},
-                    {"behavior_name": "prioritize", "score_delta": 3.0},
-                    {"behavior_name": "communicate", "score_delta": 2.0},
-                    {"behavior_name": "cooperate", "score_delta": 1.5},
-                    {"behavior_name": "remember", "score_delta": 0.5},
-                    {"behavior_name": "evaluate", "score_delta": 0.25},
-                ],
-            },
-        )
+        if role in {"hunter", "farmer"}:
+            behaviors.append(
+                BehaviorSpec(
+                    name="recommend",
+                    params={
+                        "target_agent_id": target_agent_id,
+                        "recommendation": "protect_flock_and_monitor_wolves",
+                        "confidence": 0.75,
+                    }
+                    if target_agent_id is not None
+                    else {
+                        "recommendation": "protect_flock_and_monitor_wolves",
+                        "confidence": 0.75,
+                    },
+                )
+            )
+
+        if role == "wolf":
+            behaviors.append(
+                BehaviorSpec(
+                    name="share",
+                    params={
+                        "target_agent_id": target_agent_id,
+                        "content_path": "state.pack_signal",
+                        "share_key": "pack_signal_share",
+                        "relationship_delta": 0.05,
+                    }
+                    if target_agent_id is not None
+                    else {
+                        "content_path": "state.pack_signal",
+                        "share_key": "pack_signal_share",
+                        "relationship_delta": 0.05,
+                    },
+                )
+            )
+
+        policy_rules = [
+            {"behavior_name": "choose_goal", "score_delta": 4.0, "priority_delta": 1.0},
+            {"behavior_name": "prioritize", "score_delta": 3.0},
+            {"behavior_name": "communicate", "score_delta": 2.0},
+            {"behavior_name": "cooperate", "score_delta": 1.5},
+            {"behavior_name": "evaluate", "score_delta": 1.0},
+            {"behavior_name": "update_belief", "score_delta": 0.8},
+            {"behavior_name": "remember", "score_delta": 0.5},
+        ]
+
+        if role in {"hunter", "farmer"}:
+            policy_rules.append({"behavior_name": "recommend", "score_delta": 1.2})
+
+        if role == "wolf":
+            policy_rules.append({"behavior_name": "share", "score_delta": 1.2})
 
         return AgentSpec(
             id=agent_id,
             type=role,
             position=(x, y),
-            state={
-                "energy": float(10 - index),
-                "credits": float(5 + index),
-                "influence": float(index + 1),
-                "domain_pressure": 0.2,
-            },
+            state=role_state,
             memory={
                 "goals": goal_records,
-                "known_options": {
-                    "cooperate": 1.0,
-                    "communicate": 0.8,
-                    "evaluate": 0.6,
-                },
+                "known_options": self._known_options_for_role(role),
                 "relationships": {},
+                "source_role": role,
             },
             goals=goal_records,
             behaviors=tuple(behaviors),
-            policy=policy,
+            policy=PolicySpec(
+                type="rule_policy",
+                params={
+                    "selection_strategy": "highest_score",
+                    "rules": policy_rules,
+                },
+            ),
             alive=True,
             metadata={
                 "domain": domain,
                 "generated_by": "deterministic_fallback",
+                "prompt_role": role,
             },
         )
 
+    def _roles_for_prompt(
+        self,
+        prompt: str,
+        domain: str,
+        *,
+        max_agents: int,
+    ) -> tuple[str, ...]:
+        """Return role list that preserves important prompt entities."""
+
+        text = prompt.lower()
+        roles: list[str] = []
+
+        if domain == "farm":
+            roles.append("farmer")
+
+            has_sheep = self._contains_any(text, ("sheep", "lamb", "flock"))
+            has_wolf = self._contains_any(text, ("wolf", "wolves", "pack"))
+            has_hunter = self._contains_any(text, ("hunter", "ranger", "shepherd"))
+
+            if has_sheep:
+                roles.append("sheep")
+
+            if has_wolf:
+                roles.append("wolf")
+
+            if has_hunter:
+                roles.append("hunter")
+
+            if has_sheep and len(roles) < max_agents:
+                roles.append("sheep")
+
+            if has_wolf and len(roles) < max_agents:
+                roles.append("wolf")
+
+            if not has_sheep and not has_wolf and not has_hunter:
+                roles.extend(self._roles_for_domain(domain))
+
+            return tuple(roles[:max_agents])
+
+        roles.extend(self._roles_for_domain(domain))
+        return tuple(roles[:max_agents])
+
+    def _resources_for_prompt(self, prompt: str, domain: str) -> tuple[str, ...]:
+        """Return resource types that preserve important prompt entities."""
+
+        text = prompt.lower()
+
+        if domain == "farm":
+            resources: list[str] = []
+
+            if self._contains_any(text, ("grass", "pasture")):
+                resources.append("grass")
+            else:
+                resources.append("food")
+
+            if self._contains_any(text, ("sheep", "flock", "lamb")):
+                resources.append("flock_safety")
+                resources.append("shelter")
+
+            if self._contains_any(text, ("wolf", "wolves", "pack", "hunter")):
+                resources.append("predator_pressure")
+
+            resources.append("water")
+
+            if "soil_health" not in resources:
+                resources.append("soil_health")
+
+            return tuple(dict.fromkeys(resources))
+
+        return self._resources_for_domain(domain)
+
+    def _events_for_prompt(
+        self,
+        *,
+        prompt: str,
+        domain: str,
+        roles: Sequence[str],
+        resources: Sequence[str],
+    ) -> tuple[EventSpec, ...]:
+        """Return domain events that preserve important prompt entities."""
+
+        text = prompt.lower()
+        events: list[EventSpec] = []
+
+        wolf_ids = [
+            self._agent_id_for_roles(roles, index)
+            for index, role in enumerate(roles)
+            if role == "wolf"
+        ]
+        sheep_ids = [
+            self._agent_id_for_roles(roles, index)
+            for index, role in enumerate(roles)
+            if role == "sheep"
+        ]
+        hunter_ids = [
+            self._agent_id_for_roles(roles, index)
+            for index, role in enumerate(roles)
+            if role == "hunter"
+        ]
+        farmer_ids = [
+            self._agent_id_for_roles(roles, index)
+            for index, role in enumerate(roles)
+            if role == "farmer"
+        ]
+
+        resource_ids = {
+            resource_type: self._resource_id(resource_type, index)
+            for index, resource_type in enumerate(resources)
+        }
+
+        if domain == "farm" and self._contains_any(text, ("wolf", "wolves", "pack")):
+            events.append(
+                EventSpec(
+                    id="wolf_pack_enters",
+                    name="wolf_pack_enters",
+                    trigger_step=max(1, self.default_steps // 4),
+                    payload={
+                        "description": "A pack of wolves enters the farm and increases pressure on the flock.",
+                        "signals": {
+                            "predator_pressure": 0.35,
+                            "flock_fear": 0.25,
+                        },
+                    },
+                    enabled=True,
+                    target_agent_ids=tuple(wolf_ids + sheep_ids + farmer_ids),
+                    target_resource_ids=tuple(
+                        resource_id
+                        for key, resource_id in resource_ids.items()
+                        if key in {"predator_pressure", "flock_safety", "grass"}
+                    ),
+                    metadata={
+                        "generated_by": "entity_aware_fallback",
+                        "narrative_hint": "Predator pressure tests flock safety and farm coordination.",
+                    },
+                )
+            )
+
+        if domain == "farm" and self._contains_any(text, ("hunter", "ranger")):
+            events.append(
+                EventSpec(
+                    id="hunter_enters",
+                    name="hunter_enters",
+                    trigger_step=max(2, self.default_steps // 3),
+                    payload={
+                        "description": "A hunter enters the farm area and changes the balance between wolves and sheep.",
+                        "signals": {
+                            "protection_pressure": 0.3,
+                            "wolf_caution": 0.2,
+                        },
+                    },
+                    enabled=True,
+                    target_agent_ids=tuple(hunter_ids + wolf_ids + farmer_ids + sheep_ids),
+                    target_resource_ids=tuple(
+                        resource_id
+                        for key, resource_id in resource_ids.items()
+                        if key in {"predator_pressure", "flock_safety"}
+                    ),
+                    metadata={
+                        "generated_by": "entity_aware_fallback",
+                        "narrative_hint": "Hunter arrival adds a stabilizing or disruptive force.",
+                    },
+                )
+            )
+
+        if not events:
+            events.append(
+                EventSpec(
+                    id="midpoint_pressure",
+                    name="midpoint_pressure",
+                    trigger_step=max(1, self.default_steps // 2),
+                    payload={
+                        "description": "A generic pressure event that can be narrated later.",
+                        "domain": domain,
+                    },
+                    enabled=True,
+                    metadata={"generated_by": "fallback_builder"},
+                )
+            )
+
+        return tuple(events)
+
+    def _state_for_role(self, role: str, domain: str, index: int) -> dict[str, Any]:
+        """Return role-specific initial state."""
+
+        base_state: dict[str, Any] = {
+            "energy": float(max(3, 10 - index)),
+            "credits": float(5 + index),
+            "influence": float(index + 1),
+            "domain_pressure": 0.2,
+            "inventory": {},
+        }
+
+        if role == "sheep":
+            base_state.update(
+                {
+                    "hunger": 0.4,
+                    "fear": 0.35,
+                    "herd_signal": 0.75,
+                    "grazing_need": 0.8,
+                    "inventory": {"wool": 1},
+                }
+            )
+            return base_state
+
+        if role == "wolf":
+            base_state.update(
+                {
+                    "hunger": 0.85,
+                    "pack_signal": 0.8,
+                    "caution": 0.3,
+                    "predator_intent": 0.9,
+                    "inventory": {},
+                }
+            )
+            return base_state
+
+        if role == "hunter":
+            base_state.update(
+                {
+                    "tracking_skill": 0.8,
+                    "protection_signal": 0.7,
+                    "caution": 0.55,
+                    "inventory": {"tools": 2, "supplies": 2},
+                }
+            )
+            return base_state
+
+        if role == "farmer":
+            base_state.update(
+                {
+                    "flock_care": 0.8,
+                    "grass_management": 0.65,
+                    "protection_signal": 0.5,
+                    "inventory": {"hay": 3, "tools": 2},
+                }
+            )
+            return base_state
+
+        base_state.update(
+            {
+                "role_signal": 0.6,
+                "inventory": {},
+            }
+        )
+        return base_state
+
+    def _goals_for_role(self, role: str, domain: str) -> tuple[str, ...]:
+        """Return role-specific fallback goal ids."""
+
+        if role == "sheep":
+            return ("graze_on_grass", "stay_with_flock", "avoid_wolves")
+
+        if role == "wolf":
+            return ("coordinate_pack", "seek_food_pressure", "avoid_hunter")
+
+        if role == "hunter":
+            return ("protect_flock", "track_wolves", "avoid_unnecessary_harm")
+
+        if role == "farmer":
+            return ("protect_sheep", "maintain_grass", "coordinate_hunter")
+
+        return self._goals_for_domain(domain)
+
+    def _known_options_for_role(self, role: str) -> dict[str, Any]:
+        """Return role-specific known options."""
+
+        if role == "sheep":
+            return {
+                "graze": {"score": 1.0, "energy": 0.8},
+                "flock_together": {"score": 1.2, "safety": 0.9},
+                "avoid_predator": {"score": 1.4, "safety": 1.0},
+            }
+
+        if role == "wolf":
+            return {
+                "pack_coordination": {"score": 1.3, "success": 0.8},
+                "cautious_entry": {"score": 1.0, "safety": 0.7},
+                "pressure_flock": {"score": 1.2, "food": 0.8},
+            }
+
+        if role == "hunter":
+            return {
+                "track_wolves": {"score": 1.2, "protection": 0.9},
+                "coordinate_farmer": {"score": 1.1, "trust": 0.8},
+                "guard_pasture": {"score": 1.0, "safety": 0.9},
+            }
+
+        if role == "farmer":
+            return {
+                "protect_flock": {"score": 1.2, "safety": 0.9},
+                "maintain_pasture": {"score": 1.0, "grass": 0.8},
+                "coordinate_hunter": {"score": 1.1, "protection": 0.8},
+            }
+
+        return {
+            "cooperate": 1.0,
+            "communicate": 0.8,
+            "evaluate": 0.6,
+        }
+
+    def _options_for_role(self, role: str) -> list[str]:
+        """Return candidate option ids for evaluation behavior."""
+
+        return list(self._known_options_for_role(role).keys())
+
+    def _belief_for_role(self, role: str) -> str:
+        """Return a role-specific belief proposition."""
+
+        if role == "sheep":
+            return "The flock can stay safe while grazing."
+
+        if role == "wolf":
+            return "The pack can coordinate under farm and hunter pressure."
+
+        if role == "hunter":
+            return "The hunter can reduce wolf pressure without destabilizing the farm."
+
+        if role == "farmer":
+            return "The farm can protect sheep while maintaining grass resources."
+
+        return "The current situation is manageable."
+
+    def _evidence_path_for_role(self, role: str) -> str:
+        """Return a role-specific evidence path."""
+
+        if role == "sheep":
+            return "state.herd_signal"
+
+        if role == "wolf":
+            return "state.pack_signal"
+
+        if role == "hunter":
+            return "state.protection_signal"
+
+        if role == "farmer":
+            return "state.flock_care"
+
+        return "state.domain_pressure"
+
+    def _effort_for_role(self, role: str) -> float:
+        """Return role-specific cooperation effort."""
+
+        if role in {"hunter", "farmer", "wolf"}:
+            return 1.0
+
+        if role == "sheep":
+            return 0.7
+
+        return 0.8
+
+    def _position_for_index(self, index: int) -> tuple[float, float]:
+        """Return deterministic 2D position for agent index."""
+
+        positions = (
+            (1.0, 1.0),
+            (3.0, 6.5),
+            (7.5, 6.5),
+            (8.5, 2.0),
+            (4.0, 7.5),
+            (6.5, 2.5),
+            (2.0, 4.0),
+            (8.0, 8.0),
+        )
+        return positions[index % len(positions)]
+
+    def _agent_id_for_roles(self, roles: Sequence[str], index: int) -> str:
+        """Return stable id for an agent in a possibly duplicated role list."""
+
+        role = roles[index]
+        ordinal = sum(1 for candidate in roles[: index + 1] if candidate == role)
+        return f"{role}_{ordinal}"
+
+    def _next_agent_id_for_roles(self, roles: Sequence[str], index: int) -> str | None:
+        """Return next cyclic target agent id."""
+
+        if len(roles) <= 1:
+            return None
+
+        next_index = (index + 1) % len(roles)
+        return self._agent_id_for_roles(roles, next_index)
+
+    def _resource_id(self, resource_type: str, index: int) -> str:
+        """Return stable resource id."""
+
+        return f"{_slugify(resource_type)}_{index + 1}"
+
+    def _resource_regeneration_rate(self, resource_type: str) -> float:
+        """Return resource-specific regeneration rate."""
+
+        if resource_type in {"grass", "food", "water", "soil_health"}:
+            return 0.2
+
+        if resource_type in {"flock_safety", "predator_pressure"}:
+            return 0.05
+
+        return 0.0
+
+    def _max_agents_from_constraints(
+        self,
+        constraints: Mapping[str, Any] | str | None,
+    ) -> int | None:
+        """Extract max_agents from parsed constraints when available."""
+
+        if not isinstance(constraints, Mapping):
+            return None
+
+        value = constraints.get("max_agents")
+        if value is None:
+            return None
+
+        try:
+            return max(1, int(value))
+        except (TypeError, ValueError):
+            return None
+
+    def _prompt_entity_resource_names(self, prompt: str) -> set[str]:
+        """Return resource names explicitly suggested by the prompt."""
+
+        text = prompt.lower()
+        names: set[str] = set()
+
+        if self._contains_any(text, ("grass", "pasture")):
+            names.add("grass")
+
+        return names
+
+    @staticmethod
+    def _contains_any(text: str, words: Sequence[str]) -> bool:
+        """Return whether any word-like string appears in text."""
+
+        lowered = text.lower()
+        return any(word in lowered for word in words)
+
     @staticmethod
     def _infer_domain(prompt: str) -> str:
         """Infer a broad fallback domain from prompt keywords."""
@@ -645,7 +1154,7 @@ class DeterministicWorldSpecBuilder:
         text = prompt.lower()
 
         keyword_domains = (
-            ("farm", ("farm", "crop", "soil", "harvest", "animal", "pasture")),
+            ("farm", ("farm", "crop", "soil", "harvest", "animal", "pasture", "sheep", "wolf", "wolves", "grass")),
             ("medieval", ("medieval", "kingdom", "castle", "guild", "village", "empire")),
             ("research", ("research", "scientist", "paper", "lab", "study", "knowledge")),
             ("startup", ("startup", "founder", "investor", "customer", "market", "product")),
@@ -729,7 +1238,7 @@ class DeterministicWorldSpecBuilder:
             constraint_text = f" Constraints: {constraints}"
 
         return (
-            f"A deterministic fallback {domain} world generated from the prompt: "
+            f"A deterministic entity-aware fallback {domain} world generated from the prompt: "
             f"{prompt.strip()[:240]}{constraint_text}"
         )