112 lines
3.7 KiB
Python
112 lines
3.7 KiB
Python
from __future__ import annotations
|
|
|
|
import logging
|
|
from typing import TYPE_CHECKING, Any
|
|
|
|
from core.models import Scene
|
|
from semantic.models import SemanticScene
|
|
from world.config import WorldConfig, load_config
|
|
from world.models import WorldEvent, WorldState
|
|
|
|
if TYPE_CHECKING:
|
|
from runtime.executor import StepResult
|
|
from runtime.planner import PlannedStep
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class WorldModel:
|
|
def __init__(self, *, config: WorldConfig | None = None) -> None:
|
|
self.config = config or load_config()
|
|
self._states: dict[str, WorldState] = {}
|
|
self._current_task_id: str | None = None
|
|
self._fallback_state = self._new_state()
|
|
|
|
@property
|
|
def state(self) -> WorldState:
|
|
if self._current_task_id is None:
|
|
return self._fallback_state
|
|
return self._states[self._current_task_id]
|
|
|
|
def start_task(self, task_id: str) -> WorldState:
|
|
self._current_task_id = task_id
|
|
return self._states.setdefault(task_id, self._new_state())
|
|
|
|
def state_for(self, task_id: str) -> WorldState | None:
|
|
return self._states.get(task_id)
|
|
|
|
def observe(
|
|
self,
|
|
scene: Scene,
|
|
semantic_scene: SemanticScene | None,
|
|
step: "PlannedStep",
|
|
result: "StepResult",
|
|
) -> None:
|
|
try:
|
|
self._update_page(semantic_scene)
|
|
self._update_app(step, result)
|
|
self._update_variables(step)
|
|
self._append_history(scene, semantic_scene, step, result)
|
|
except Exception as exc:
|
|
logger.info("world model update skipped after unexpected error: %s", exc)
|
|
|
|
def _new_state(self) -> WorldState:
|
|
return WorldState.with_history_bound(self.config.history_size)
|
|
|
|
def _update_page(self, semantic_scene: SemanticScene | None) -> None:
|
|
if semantic_scene is None:
|
|
return
|
|
page = semantic_scene.page.strip()
|
|
if page:
|
|
self.state.current_page = page
|
|
|
|
def _update_app(self, step: "PlannedStep", result: "StepResult") -> None:
|
|
if not getattr(result, "success", False):
|
|
return
|
|
action = getattr(step, "action", None)
|
|
if action not in {"launch_app", "terminate_app"}:
|
|
return
|
|
|
|
args = getattr(step, "args", {})
|
|
if not isinstance(args, dict):
|
|
logger.info("world model skipped app update: step args are not a mapping")
|
|
return
|
|
app_id = _app_identifier(args)
|
|
if not app_id:
|
|
logger.info("world model skipped app update: missing app identifier")
|
|
return
|
|
if action == "launch_app":
|
|
self.state.current_app = app_id
|
|
return
|
|
self.state.current_app = None
|
|
|
|
def _update_variables(self, step: "PlannedStep") -> None:
|
|
args = getattr(step, "args", {})
|
|
if not isinstance(args, dict) or "remember" not in args:
|
|
return
|
|
remember = args["remember"]
|
|
if not isinstance(remember, dict):
|
|
logger.info("world model skipped remember update: value is not a mapping")
|
|
return
|
|
self.state.variables.update(remember)
|
|
|
|
def _append_history(
|
|
self,
|
|
scene: Scene,
|
|
semantic_scene: SemanticScene | None,
|
|
step: "PlannedStep",
|
|
result: "StepResult",
|
|
) -> None:
|
|
self.state.history.append(
|
|
WorldEvent(
|
|
scene_summary=semantic_scene or scene,
|
|
action=str(getattr(step, "action", "unknown")),
|
|
success=bool(getattr(result, "success", False)),
|
|
)
|
|
)
|
|
|
|
|
|
def _app_identifier(args: dict[str, Any]) -> str | None:
|
|
value = args.get("bundle_id") or args.get("app_id")
|
|
return value if isinstance(value, str) and value.strip() else None
|