rebase

app/api/worlds.py

@@ -0,0 +1,182 @@
+"""Worlds API — CRUD + world_builder stream + world_editor stream."""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime, timezone
+
+from fastapi import APIRouter, Depends, HTTPException, Response, status
+from fastapi.responses import StreamingResponse
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.deps import get_current_user, get_settings_dict
+from app.core.llm import LlmClient, MockLlmClient
+from app.core.logging import get_logger
+from app.core.settings_service import get_all_settings
+from app.db import get_db
+from app.engine.sse import SseEmitter
+from app.engine.world_builder import run_world_builder
+from app.engine.world_editor import run_world_editor
+from app.models import User, World, WorldPreset
+from app.schemas import (
+    WorldCreateRequest,
+    WorldEditRequest,
+    WorldFull,
+    WorldPatchRequest,
+    WorldSummary,
+)
+
+_logger = get_logger(__name__)
+
+router = APIRouter(prefix="/api/worlds", tags=["worlds"])
+
+
+def _llm_factory(settings: dict) -> LlmClient | MockLlmClient:
+    """Construct an LLM client. Falls back to MockLlmClient if no api_url configured."""
+    api_url = settings.get("llm.api_url", "")
+    if not api_url:
+        _logger.warning("llm_not_configured_using_mock")
+        return MockLlmClient()
+    return LlmClient.from_settings(settings)
+
+
+@router.get("", response_model=dict)
+async def list_worlds(
+    page: int = 1,
+    per_page: int = 20,
+    status_filter: str | None = None,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+) -> dict:
+    """List the current user's worlds."""
+    stmt = select(World).where(World.owner_id == user.id)
+    if status_filter and status_filter != "all":
+        stmt = stmt.where(World.status == status_filter)
+    total = (await db.execute(select(func.count()).select_from(stmt.subquery()))).scalar_one()
+    stmt = stmt.order_by(World.last_played_at.desc().nullslast(), World.created_at.desc())
+    stmt = stmt.offset((page - 1) * per_page).limit(per_page)
+    rows = (await db.execute(stmt)).scalars().all()
+    items = []
+    for w in rows:
+        env = w.environment or {}
+        player = env.get("player") if isinstance(env, dict) else None
+        pname = player.get("name") if isinstance(player, dict) else None
+        items.append({
+            "id": str(w.id), "name": w.name, "description": w.description,
+            "language": w.language, "status": w.status,
+            "last_played_at": w.last_played_at.isoformat() if w.last_played_at else None,
+            "current_time": w.current_time,
+            "created_at": w.created_at.isoformat(),
+            "preview_player_name": pname,
+        })
+    return {"items": items, "total": total, "page": page, "per_page": per_page}
+
+
+@router.post("", response_model=dict, status_code=status.HTTP_202_ACCEPTED)
+async def create_world(
+    body: WorldCreateRequest,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+    settings: dict = Depends(get_settings_dict),
+) -> dict:
+    """Create a draft world and start the world_builder flow (SSE)."""
+    preset: WorldPreset | None = None
+    if body.mode == "preset":
+        if body.preset_id is None:
+            raise HTTPException(400, "preset_id required when mode=preset")
+        preset = (
+            await db.execute(select(WorldPreset).where(WorldPreset.id == body.preset_id))
+        ).scalar_one_or_none()
+        if preset is None:
+            raise HTTPException(404, "preset not found")
+        if not preset.is_public and preset.owner_id != user.id and not user.is_admin:
+            raise HTTPException(403, "preset not accessible")
+    world = World(
+        owner_id=user.id,
+        preset_id=preset.id if preset else None,
+        name=body.name,
+        description=body.notes,
+        language=body.language,
+        status="draft",
+        current_time="day_1_hour_8",
+    )
+    if preset:
+        world.rules = preset.rules
+        world.time_schema = preset.time_schema
+        world.schemas = preset.schemas
+        world.environment_schema = preset.environment_schema
+        world.environment = dict(preset.environment_initial)
+    db.add(world)
+    await db.commit()
+    await db.refresh(world)
+    return {
+        "world_id": str(world.id),
+        "stream_url": f"/api/sessions/worlds/{world.id}/builder/stream",
+    }
+
+
+@router.get("/{world_id}", response_model=WorldFull)
+async def get_world(
+    world_id: uuid.UUID,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+) -> World:
+    world = _load_world(db, world_id, user)
+    return await world
+
+
+@router.patch("/{world_id}", response_model=WorldFull)
+async def patch_world(
+    world_id: uuid.UUID,
+    body: WorldPatchRequest,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+) -> World:
+    world = await _load_world(db, world_id, user)
+    # Optimistic locking
+    if body.updated_at is not None and body.updated_at != world.updated_at:
+        raise HTTPException(409, "state_conflict")
+    for k, v in body.model_dump(exclude_unset=True, exclude_none=True).items():
+        if k == "updated_at":
+            continue
+        setattr(world, k, v)
+    await db.commit()
+    await db.refresh(world)
+    return world
+
+
+@router.delete("/{world_id}", status_code=status.HTTP_204_NO_CONTENT, response_class=Response)
+async def delete_world(
+    world_id: uuid.UUID,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+) -> Response:
+    world = await _load_world(db, world_id, user)
+    world.status = "archived"
+    await db.commit()
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+@router.post("/{world_id}/edit", response_model=dict, status_code=status.HTTP_202_ACCEPTED)
+async def edit_world(
+    world_id: uuid.UUID,
+    body: WorldEditRequest,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(get_current_user),
+    settings: dict = Depends(get_settings_dict),
+) -> dict:
+    """Start the world_editor flow with a text instruction."""
+    world = await _load_world(db, world_id, user)
+    return {"stream_url": f"/api/sessions/worlds/{world.id}/editor/stream?instruction={body.instruction}"}
+
+
+async def _load_world(db: AsyncSession, world_id: uuid.UUID, user: User) -> World:
+    world = (
+        await db.execute(select(World).where(World.id == world_id))
+    ).scalar_one_or_none()
+    if world is None:
+        raise HTTPException(404, "not_found")
+    if world.owner_id != user.id and not user.is_admin:
+        raise HTTPException(403, "not_owner")
+    return world