337 lines
11 KiB
Python
337 lines
11 KiB
Python
from functools import partial
|
|
from itertools import count
|
|
from json import loads
|
|
from logging import getLogger
|
|
from math import inf
|
|
from typing import Callable, Sequence
|
|
|
|
from packit.agent import Agent
|
|
from packit.conditions import condition_or, condition_threshold
|
|
from packit.loops import loop_retry
|
|
from packit.results import function_result
|
|
from packit.toolbox import Toolbox
|
|
from packit.utils import could_be_json
|
|
|
|
from taleweave.actions.base import (
|
|
action_ask,
|
|
action_examine,
|
|
action_give,
|
|
action_move,
|
|
action_take,
|
|
action_tell,
|
|
)
|
|
from taleweave.actions.planning import (
|
|
check_calendar,
|
|
erase_notes,
|
|
get_recent_notes,
|
|
read_notes,
|
|
replace_note,
|
|
schedule_event,
|
|
summarize_notes,
|
|
take_note,
|
|
)
|
|
from taleweave.context import (
|
|
broadcast,
|
|
get_character_agent_for_name,
|
|
get_character_for_agent,
|
|
get_current_turn,
|
|
get_current_world,
|
|
set_current_character,
|
|
set_current_room,
|
|
set_current_turn,
|
|
set_current_world,
|
|
set_game_systems,
|
|
)
|
|
from taleweave.game_system import GameSystem
|
|
from taleweave.models.config import DEFAULT_CONFIG
|
|
from taleweave.models.entity import Character, Room, World
|
|
from taleweave.models.event import ActionEvent, ResultEvent
|
|
from taleweave.utils.conversation import make_keyword_condition, summarize_room
|
|
from taleweave.utils.effect import expire_effects
|
|
from taleweave.utils.planning import expire_events, get_upcoming_events
|
|
from taleweave.utils.search import find_containing_room
|
|
from taleweave.utils.world import describe_entity, format_attributes
|
|
|
|
logger = getLogger(__name__)
|
|
|
|
|
|
turn_config = DEFAULT_CONFIG.world.turn
|
|
|
|
|
|
def world_result_parser(value, agent, **kwargs):
|
|
current_world = get_current_world()
|
|
if not current_world:
|
|
raise ValueError(
|
|
"The current world must be set before calling world_result_parser"
|
|
)
|
|
|
|
logger.debug(f"parsing action for {agent.name}: {value}")
|
|
|
|
current_character = get_character_for_agent(agent)
|
|
current_room = next(
|
|
(room for room in current_world.rooms if current_character in room.characters),
|
|
None,
|
|
)
|
|
|
|
set_current_room(current_room)
|
|
set_current_character(current_character)
|
|
|
|
return function_result(value, agent=agent, **kwargs)
|
|
|
|
|
|
def prompt_character_action(
|
|
room, character, agent, action_names, action_toolbox, current_turn
|
|
) -> str:
|
|
# collect data for the prompt
|
|
notes_prompt, events_prompt = get_notes_events(character, current_turn)
|
|
|
|
room_characters = [character.name for character in room.characters]
|
|
room_items = [item.name for item in room.items]
|
|
room_directions = [portal.name for portal in room.portals]
|
|
|
|
character_attributes = format_attributes(character)
|
|
# character_effects = [effect.name for effect in character.active_effects]
|
|
character_items = [item.name for item in character.items]
|
|
|
|
# set up a result parser for the agent
|
|
def result_parser(value, **kwargs):
|
|
if not room or not character:
|
|
raise ValueError("Room and character must be set before parsing results")
|
|
|
|
# trim suffixes that are used elsewhere
|
|
value = value.removesuffix("END").strip()
|
|
|
|
# fix unbalanced curly braces
|
|
if value.startswith("{") and not value.endswith("}"):
|
|
open_count = value.count("{")
|
|
close_count = value.count("}")
|
|
|
|
if open_count > close_count:
|
|
fixed_value = value + ("}" * (open_count - close_count))
|
|
try:
|
|
loads(fixed_value)
|
|
value = fixed_value
|
|
except Exception:
|
|
pass
|
|
|
|
if could_be_json(value):
|
|
# TODO: only emit valid actions that parse and run correctly
|
|
event = ActionEvent.from_json(value, room, character)
|
|
else:
|
|
# TODO: this path should be removed and throw
|
|
event = ResultEvent(value, room, character)
|
|
|
|
broadcast(event)
|
|
|
|
return world_result_parser(value, **kwargs)
|
|
|
|
# prompt and act
|
|
logger.info("starting turn for character: %s", character.name)
|
|
result = loop_retry(
|
|
agent,
|
|
(
|
|
"You are currently in the {room_name} room. {room_description}. {attributes}. "
|
|
"The room contains the following characters: {visible_characters}. "
|
|
"The room contains the following items: {visible_items}. "
|
|
"Your inventory contains the following items: {character_items}."
|
|
"You can take the following actions: {actions}. "
|
|
"You can move in the following directions: {directions}. "
|
|
"{notes_prompt} {events_prompt}"
|
|
"What will you do next? Reply with a JSON function call, calling one of the actions."
|
|
"You can only perform one action per turn. What is your next action?"
|
|
),
|
|
context={
|
|
"actions": action_names,
|
|
"character_items": character_items,
|
|
"attributes": character_attributes,
|
|
"directions": room_directions,
|
|
"room_name": room.name,
|
|
"room_description": describe_entity(room),
|
|
"visible_characters": room_characters,
|
|
"visible_items": room_items,
|
|
"notes_prompt": notes_prompt,
|
|
"events_prompt": events_prompt,
|
|
},
|
|
result_parser=result_parser,
|
|
toolbox=action_toolbox,
|
|
)
|
|
|
|
logger.debug(f"{character.name} action result: {result}")
|
|
if agent.memory:
|
|
# TODO: make sure this is not duplicating memories and wasting space
|
|
agent.memory.append(result)
|
|
|
|
return result
|
|
|
|
|
|
def get_notes_events(character: Character, current_turn: int):
|
|
recent_notes = get_recent_notes(character)
|
|
upcoming_events = get_upcoming_events(character, current_turn)
|
|
|
|
if len(recent_notes) > 0:
|
|
notes = "\n".join(recent_notes)
|
|
notes_prompt = f"Your recent notes are: {notes}\n"
|
|
else:
|
|
notes_prompt = "You have no recent notes.\n"
|
|
|
|
if len(upcoming_events) > 0:
|
|
current_turn = get_current_turn()
|
|
events = [
|
|
f"{event.name} in {event.turn - current_turn} turns"
|
|
for event in upcoming_events
|
|
]
|
|
events = "\n".join(events)
|
|
events_prompt = f"Upcoming events are: {events}\n"
|
|
else:
|
|
events_prompt = "You have no upcoming events.\n"
|
|
|
|
return notes_prompt, events_prompt
|
|
|
|
|
|
def prompt_character_think(
|
|
room: Room,
|
|
character: Character,
|
|
agent: Agent,
|
|
planner_toolbox: Toolbox,
|
|
current_turn: int,
|
|
max_steps: int | None = None,
|
|
) -> str:
|
|
max_steps = max_steps or turn_config.planning_steps
|
|
|
|
notes_prompt, events_prompt = get_notes_events(character, current_turn)
|
|
|
|
event_count = len(character.planner.calendar.events)
|
|
note_count = len(character.planner.notes)
|
|
|
|
logger.info("starting planning for character: %s", character.name)
|
|
_, condition_end, result_parser = make_keyword_condition("You are done planning.")
|
|
stop_condition = condition_or(
|
|
condition_end, partial(condition_threshold, max=max_steps)
|
|
)
|
|
|
|
i = 0
|
|
while not stop_condition(current=i):
|
|
result = loop_retry(
|
|
agent,
|
|
"You are about to start your turn. Plan your next action carefully. Take notes and schedule events to help keep track of your goals. "
|
|
"You can check your notes for important facts or check your calendar for upcoming events. You have {note_count} notes. "
|
|
"If you have plans with other characters, schedule them on your calendar. You have {event_count} events on your calendar. "
|
|
"{room_summary}"
|
|
"Think about your goals and any quests that you are working on, and plan your next action accordingly. "
|
|
"Try to keep your notes accurate and up-to-date. Replace or erase old notes when they are no longer accurate or useful. "
|
|
"Do not keeps notes about upcoming events, use your calendar for that. "
|
|
"You can perform up to 3 planning actions in a single turn. When you are done planning, reply with 'END'."
|
|
"{notes_prompt} {events_prompt}",
|
|
context={
|
|
"event_count": event_count,
|
|
"events_prompt": events_prompt,
|
|
"note_count": note_count,
|
|
"notes_prompt": notes_prompt,
|
|
"room_summary": summarize_room(room, character),
|
|
},
|
|
result_parser=result_parser,
|
|
stop_condition=stop_condition,
|
|
toolbox=planner_toolbox,
|
|
)
|
|
|
|
if agent.memory:
|
|
agent.memory.append(result)
|
|
|
|
i += 1
|
|
|
|
return result
|
|
|
|
|
|
def simulate_world(
|
|
world: World,
|
|
turns: float | int = inf,
|
|
actions: Sequence[Callable[..., str]] = [],
|
|
systems: Sequence[GameSystem] = [],
|
|
):
|
|
logger.info("simulating the world")
|
|
set_current_world(world)
|
|
set_game_systems(systems)
|
|
|
|
# build a toolbox for the actions
|
|
action_tools = Toolbox(
|
|
[
|
|
action_ask,
|
|
action_give,
|
|
action_examine,
|
|
action_move,
|
|
action_take,
|
|
action_tell,
|
|
*actions,
|
|
]
|
|
)
|
|
action_names = action_tools.list_tools()
|
|
|
|
# build a toolbox for the planners
|
|
planner_toolbox = Toolbox(
|
|
[
|
|
check_calendar,
|
|
erase_notes,
|
|
read_notes,
|
|
replace_note,
|
|
schedule_event,
|
|
summarize_notes,
|
|
take_note,
|
|
]
|
|
)
|
|
|
|
# simulate each character
|
|
for i in count():
|
|
current_turn = get_current_turn()
|
|
logger.info(f"simulating turn {i} of {turns} (world turn {current_turn})")
|
|
|
|
for character_name in world.order:
|
|
character, agent = get_character_agent_for_name(character_name)
|
|
if not agent or not character:
|
|
logger.error(f"agent or character not found for name {character_name}")
|
|
continue
|
|
|
|
room = find_containing_room(world, character)
|
|
if not room:
|
|
logger.error(f"character {character_name} is not in a room")
|
|
continue
|
|
|
|
# prep context
|
|
set_current_room(room)
|
|
set_current_character(character)
|
|
|
|
# decrement effects on the character and remove any that have expired
|
|
expire_effects(character)
|
|
expire_events(character, current_turn)
|
|
|
|
# give the character a chance to think and check their planner
|
|
if agent.memory and len(agent.memory) > 0:
|
|
try:
|
|
thoughts = prompt_character_think(
|
|
room, character, agent, planner_toolbox, current_turn
|
|
)
|
|
logger.debug(f"{character.name} thinks: {thoughts}")
|
|
except Exception:
|
|
logger.exception(
|
|
f"error during planning for character {character.name}"
|
|
)
|
|
|
|
try:
|
|
result = prompt_character_action(
|
|
room, character, agent, action_names, action_tools, current_turn
|
|
)
|
|
result_event = ResultEvent(
|
|
result=result, room=room, character=character
|
|
)
|
|
broadcast(result_event)
|
|
except Exception:
|
|
logger.exception(f"error during action for character {character.name}")
|
|
|
|
for system in systems:
|
|
if system.simulate:
|
|
system.simulate(world, current_turn)
|
|
|
|
set_current_turn(current_turn + 1)
|
|
if i >= turns:
|
|
logger.info("reached turn limit at world turn %s", current_turn + 1)
|
|
break
|