dndkit 0.4.0__py3-none-any.whl

dndkit/tools/render.py

@@ -0,0 +1,281 @@
+"""Plain-text views of game data, written for a model that will speak them.
+
+No emoji and little markup: a voice model reads these, then says what
+matters in its own words.
+"""
+
+from datetime import datetime
+
+from dndkit.game import characters, effects, proficiencies, seating
+from dndkit.game.spellbook import describe_slots
+from dndkit.models import (
+    ABILITIES,
+    NPC,
+    AdventureEvent,
+    Campaign,
+    Character,
+    Location,
+    Quest,
+    SessionNote,
+)
+from dndkit.storage import CampaignEntry
+from dndkit.tools import render_combat, render_map
+
+
+def character_line(c: Character) -> str:
+    """One-line summary: name, ID, class and hit points."""
+    cls = c.character_class
+    return (
+        f"{c.name} (id {c.id}): level {cls.level} {c.race.name} {cls.name}, "
+        f"HP {c.hit_points_current}/{c.hp_maximum}{_down(c)}, AC {c.armor_class}"
+    )
+
+
+def _down(c: Character) -> str:
+    """How a character at 0 HP fares: dying, stable or dead."""
+    if c.hit_points_current > 0:
+        return ""
+    if c.death_saves_failure >= 3:
+        return " (dead)"
+    return " (stable)" if c.stable else " (dying)"
+
+
+def character_sheet(c: Character) -> str:
+    """The full sheet, one fact per line, empty sections left out."""
+    scores = ", ".join(
+        f"{name[:3].upper()} {c.abilities[name].score} ({c.abilities[name].mod:+d})"
+        for name in ABILITIES
+        if name in c.abilities
+    )
+    lines = [
+        character_line(c),
+        f"Player: {c.player_name or 'unknown'}. Background: {c.background or 'none'}. "
+        f"Alignment: {c.alignment or 'none'}.",
+        f"Abilities: {scores}.",
+        f"Speed {c.speed} ft. Initiative {characters.initiative(c):+d}. "
+        f"Temporary HP {c.temporary_hit_points}. Proficiency +{c.proficiency_bonus}. "
+        f"Inspiration: {'yes' if c.inspiration else 'no'}. XP {c.experience_points}.",
+    ]
+    if c.concentration:
+        lines.append(f"Concentrating on {c.concentration}.")
+    casting = spellcasting_line(c)
+    if casting:
+        lines.append(casting)
+    if c.conditions or c.exhaustion:
+        exhaustion = [f"exhaustion {c.exhaustion}"] if c.exhaustion else []
+        lines.append(f"Conditions: {', '.join(filter(None, [effects.timed(c), *exhaustion]))}.")
+    if c.hit_points_current == 0:
+        lines.append(
+            f"Death saves: {c.death_saves_success} successes, {c.death_saves_failure} failures."
+        )
+    lines += [f"{label}: {value}" for label, value in _sheet_extras(c).items() if value]
+    return "\n".join(lines)
+
+
+def _sheet_extras(c: Character) -> dict[str, str | None]:
+    return {
+        "Description": c.description,
+        "Bio": c.bio,
+        "Inventory": ", ".join(f"{i.name} x{i.quantity}" for i in c.inventory),
+        "Spell slots": describe_slots(c) if c.spell_slots else "",
+        "Spells": ", ".join(
+            f"{s.name} ({'cantrip' if s.level == 0 else f'level {s.level}'}"
+            f"{', prepared' if s.prepared else ''})"
+            for s in sorted(c.spells_known, key=lambda s: (s.level, s.name))
+        ),
+        "Skills": _listed(proficiencies.skill_bonuses(c)),
+        "Saving throws": _listed(proficiencies.save_bonuses(c), short=True),
+        "Other checks": (
+            f"+{bonus} (Jack of All Trades)"
+            if (bonus := proficiencies.jack_of_all_trades(c))
+            else ""
+        ),
+        "Features": ", ".join(c.features_and_traits),
+        "Languages": ", ".join(c.languages),
+        "Notes": c.notes,
+    }
+
+
+def _listed(shown: list[proficiencies.Proficiency], short: bool = False) -> str:
+    """ "Stealth +5, Arcana +4": a bonus where the rules know it."""
+    return ", ".join(
+        (p.name[:3].upper() if short else p.name)
+        + (f" {p.bonus:+d}" if p.bonus is not None else "")
+        for p in shown
+    )
+
+
+def npc(n: NPC) -> str:
+    """An NPC, private bio included: the game master's eyes only."""
+    lines = [
+        f"{n.name} (id {n.id}): {n.race or 'unknown race'}, {n.occupation or 'no occupation'}, "
+        f"at {n.location or 'unknown location'}, attitude {n.attitude or 'unknown'}."
+    ]
+    lines += [
+        f"{label}: {value}"
+        for label, value in (("Description", n.description), ("Bio", n.bio), ("Notes", n.notes))
+        if value
+    ]
+    if n.relationships:
+        lines.append(
+            "Relationships: " + ", ".join(f"{k}: {v}" for k, v in n.relationships.items())
+        )
+    return "\n".join(lines)
+
+
+def location(loc: Location) -> str:
+    """A location and what is known about it."""
+    lines = [f"{loc.name} (id {loc.id}), {loc.location_type}: {loc.description}"]
+    if loc.population is not None:
+        lines.append(f"Population: {loc.population}.")
+    optional = {
+        "Government": loc.government,
+        "Notable features": "; ".join(loc.notable_features),
+        "NPCs": ", ".join(loc.npcs),
+        "Connections": ", ".join(loc.connections),
+        "Notes": loc.notes,
+    }
+    lines += [f"{label}: {value}" for label, value in optional.items() if value]
+    return "\n".join(lines)
+
+
+def quest(q: Quest) -> str:
+    """A quest with its objectives numbered and marked done or open."""
+    lines = [f"{q.title} (id {q.id}), {q.status}: {q.description}"]
+    if q.giver:
+        lines.append(f"Given by {q.giver}.")
+    for number, objective in enumerate(q.objectives, 1):
+        mark = "done" if objective in q.completed_objectives else "open"
+        lines.append(f"{number}. [{mark}] {objective}")
+    lines += [
+        f"{label}: {value}" for label, value in (("Reward", q.reward), ("Notes", q.notes)) if value
+    ]
+    return "\n".join(lines)
+
+
+ROLL_CALL = (
+    "{what}. As soon as a player says who they are, call seat_players with them and "
+    "their character (start_over the first time tonight); the others join as they speak."
+)
+
+
+def game_state(campaign: Campaign, session_start: datetime | None = None) -> str:
+    """Where the party stands right now."""
+    state = campaign.game_state
+    active = [q.title for q in campaign.quests.values() if q.status == "active"]
+    party = sorted(campaign.characters.values(), key=lambda c: c.name)
+    lines = [
+        f"Campaign {campaign.name}, session {state.current_session}.",
+        f"Location: {state.current_location or 'unknown'}. "
+        f"In-game date: {state.current_date_in_game or 'unknown'}.",
+        f"Funds {state.party_funds}.",
+        "Party: "
+        + (
+            ", ".join(
+                f"{c.name} (level {c.character_class.level}) "
+                f"HP {c.hit_points_current}/{c.hp_maximum}{_down(c)}"
+                for c in party
+            )
+            or "none"
+        ),
+        f"Active quests: {', '.join(active) or 'none'}.",
+        table(campaign, session_start),
+    ]
+    if state.in_combat:
+        lines.append("In combat. " + render_combat.initiative(campaign))
+        where = render_map.positions(campaign)
+        if where:
+            lines.append(where)
+    if state.notes:
+        lines.append(f"Notes: {state.notes}")
+    return "\n".join(lines)
+
+
+def spellcasting_line(c: Character) -> str:
+    """ "Casts with intelligence: spell attack +5, save DC 13." or "" for a non-caster."""
+    casting = characters.spellcasting(c)
+    if casting is None:
+        return ""
+    return (
+        f"Casts with {casting.ability}: spell attack {casting.attack:+d}, "
+        f"save DC {casting.save_dc}."
+    )
+
+
+def table(campaign: Campaign, session_start: datetime | None = None) -> str:
+    """Who plays which character tonight, so the model knows whom it speaks to.
+
+    Until seat_players has run since *session_start* (this server's start), it
+    says what to call: a small model reads a tool's answer, not always its prompt.
+    """
+    party = sorted(campaign.characters.values(), key=lambda c: c.name)
+    state = campaign.game_state
+    present = state.players_present
+    if not present:
+        known = [f"{c.player_name} plays {c.name}" for c in party if c.player_name]
+        return ROLL_CALL.format(what="Nobody is seated yet") + (
+            f" Players seen before: {', '.join(known)}." if known else ""
+        )
+    stale = session_start is not None and (
+        state.roll_call_at is None or state.roll_call_at < session_start
+    )
+    seats = []
+    for player in present:
+        played = " and ".join(c.name for c in seating.characters_of(campaign, player))
+        seats.append(f"{player} plays {played}" if played else f"{player} has no character yet")
+    lines = [f"At the table: {'; '.join(seats)}."]
+    if stale:
+        lines.insert(0, ROLL_CALL.format(what="This was last session's table"))
+    away = [
+        f"{c.name} ({c.player_name})"
+        for c in party
+        if c.player_name and not seating.is_present(campaign, c)
+    ]
+    if away:
+        lines.append(f"Absent: {', '.join(away)}.")
+    unplayed = [c.name for c in party if not c.player_name]
+    if unplayed:
+        lines.append(f"Nobody plays {', '.join(unplayed)}.")
+    return " ".join(lines)
+
+
+def campaign_contents(entry: CampaignEntry) -> str:
+    """What a campaign holds, e.g. "3 characters, 5 NPCs, ... and 12 log events"."""
+    return (
+        f"{entry.characters} characters, {entry.npcs} NPCs, {entry.locations} locations, "
+        f"{entry.quests} quests, {entry.session_notes} session notes "
+        f"and {entry.events} log events"
+    )
+
+
+def campaign_entry(entry: CampaignEntry, active: bool) -> str:
+    """One saved campaign: pitch, size, session and when it was last used."""
+    marker = " (active)" if active else ""
+    if not entry.readable:
+        return f"{entry.name}{marker}: the file cannot be read."
+    pitch = f" {_short(entry.description, 100)}." if entry.description else ""
+    return (
+        f"{entry.name}{marker}:{pitch} {entry.characters} characters, "
+        f"{entry.quests} quests, at session {entry.current_session}, "
+        f"last used {entry.modified:%Y-%m-%d %H:%M}."
+    )
+
+
+def session_line(note: SessionNote) -> str:
+    """One session note, summary shortened."""
+    title = f" '{note.title}'" if note.title else ""
+    return f"Session {note.session_number}{title} ({note.date:%Y-%m-%d}): {_short(note.summary)}"
+
+
+def event_line(event: AdventureEvent) -> str:
+    """One adventure log entry."""
+    where = f" at {event.location}" if event.location else ""
+    session = f", session {event.session_number}" if event.session_number else ""
+    return (
+        f"[{event.event_type}, importance {event.importance}{session}] "
+        f"{event.title}{where}: {_short(event.description, 200)}"
+    )
+
+
+def _short(text: str, limit: int = 150) -> str:
+    return text if len(text) <= limit else text[: limit - 3].rstrip() + "..."

dndkit/tools/render_combat.py

@@ -0,0 +1,121 @@
+"""Plain-text views of fights, monsters and encounters."""
+
+from dndkit.game import bestiary, effects, rules
+from dndkit.models import (
+    Campaign,
+    Character,
+    Combatant,
+    Encounter,
+    EncounterGroup,
+    Monster,
+)
+
+
+def combatant_line(campaign: Campaign, combatant: Combatant) -> str:
+    """Initiative, hit points, AC and conditions, from the sheet for a character."""
+    character = campaign.characters.get(combatant.character_id or "")
+    parts = [f"initiative {combatant.initiative}"]
+    if character is not None:
+        parts.append(f"HP {character.hit_points_current}/{character.hp_maximum}")
+        parts.append(f"AC {character.armor_class}")
+        holder: Character | Combatant = character
+    else:
+        if combatant.hit_points is not None:
+            parts.append(f"HP {combatant.hit_points}/{combatant.hit_points_max}")
+        if combatant.armor_class is not None:
+            parts.append(f"AC {combatant.armor_class}")
+        holder = combatant
+    if holder.conditions:
+        parts.append(effects.timed(holder))
+    held = character.concentration if character is not None else combatant.concentration
+    if held:
+        parts.append(f"concentrating on {held}")
+    if combatant.position:
+        parts.append(f"at {combatant.position}")
+    if combatant.reaction_used:
+        parts.append("reaction used")
+    if combatant.hidden:
+        parts.append("hidden from the players")
+    if combatant.boss:
+        parts.append("boss")
+    if combatant.legendary_actions or combatant.legendary_resistances_left:
+        parts.append(
+            f"legendary actions {combatant.legendary_actions_left}/"
+            f"{combatant.legendary_actions}, resistances {combatant.legendary_resistances_left}"
+        )
+    return "; ".join(parts)
+
+
+def turn_hint(campaign: Campaign, combatant: Combatant) -> str | None:
+    """What a character down at 0 HP does on their turn."""
+    character = campaign.characters.get(combatant.character_id or "")
+    if character is None or character.hit_points_current > 0:
+        return None
+    if character.death_saves_failure >= 3:
+        return f"{character.name} is dead: call next_turn."
+    if character.stable:
+        return f"{character.name} is stable at 0 HP: call next_turn."
+    return f"{character.name} is down: roll a death save (d20) and call record_death_save."
+
+
+def initiative(campaign: Campaign) -> str:
+    """The initiative order, the current combatant marked."""
+    state = campaign.game_state
+    current = state.current_combatant
+    rows = [
+        f"{n}. {c.name} ({combatant_line(campaign, c)}){' <- now' if c is current else ''}"
+        for n, c in enumerate(state.initiative_order, 1)
+    ]
+    return f"Round {state.combat_round}.\n" + "\n".join(rows)
+
+
+def monster(m: Monster) -> str:
+    """A saved stat block."""
+    challenge = f", CR {m.challenge_rating}" if m.challenge_rating else ""
+    speed = f", speed {m.speed.rstrip('. ')}" if m.speed else ""
+    size = f", {m.size}" if m.size != "medium" else ""
+    lines = [
+        f"{m.name}{' (boss)' if m.boss else ''}: AC {m.armor_class}, HP {m.hit_points}"
+        f"{challenge}, {m.xp} XP, initiative {m.initiative_bonus:+d}{speed}{size}."
+    ]
+    if m.legendary_actions or m.legendary_resistances:
+        lines.append(
+            f"Legendary: {m.legendary_actions} actions a round, "
+            f"{m.legendary_resistances} resistances a day."
+        )
+    lines += [
+        f"{label}: {value}"
+        for label, value in (("Actions", m.actions), ("Notes", m.notes))
+        if value
+    ]
+    return "\n".join(lines)
+
+
+def encounter(campaign: Campaign, e: Encounter) -> str:
+    """An encounter with its monsters and its difficulty for the current party."""
+    groups = ", ".join(_group(g) for g in e.monsters) or "no monster"
+    where = f" at {e.location}" if e.location else ""
+    line = f"{e.name} [{e.status}]{where}: {groups}."
+    if e.battlefield is not None:
+        line += f" On a {e.battlefield.width}x{e.battlefield.height} battle map."
+    rated = bestiary.difficulty(campaign, e)
+    if rated is not None:
+        line += f" {difficulty(rated)}"
+    if e.description:
+        line += f" {e.description}"
+    return line
+
+
+def _group(g: EncounterGroup) -> str:
+    details = [*(["hidden"] if g.hidden else []), *([f"at {', '.join(g.at)}"] if g.at else [])]
+    return f"{g.count} {g.monster}" + (f" ({'; '.join(details)})" if details else "")
+
+
+def difficulty(rated: rules.Difficulty) -> str:
+    """A difficulty rating with its numbers."""
+    easy, medium, hard, deadly = rated.thresholds
+    return (
+        f"Difficulty {rated.rating}: {rated.total_xp} XP, adjusted {rated.adjusted_xp} "
+        f"(x{rated.multiplier:g}); party thresholds easy {easy}, medium {medium}, "
+        f"hard {hard}, deadly {deadly}."
+    )

dndkit/tools/render_map.py

@@ -0,0 +1,141 @@
+"""The battle map in words: a text grid, who stands where, what a move did.
+
+The model never sees the drawn map, so these say what it needs to describe
+the scene and rule on the next action: squares, distances, who is in reach.
+"""
+
+from dndkit.game import battlefield, grid
+from dndkit.game.areas import Area
+from dndkit.game.movement import Move
+from dndkit.game.sight import COVER_BONUS, Sightline
+from dndkit.models import Campaign, Combatant, GameState
+
+KEYS = "abcdefghijklmnopqrstuvwxyz"
+
+
+def battle_map(campaign: Campaign) -> str:
+    """The grid (# wall, ~ difficult, a letter per combatant) and its legend."""
+    state = campaign.game_state
+    field = battlefield.require(state)
+    walls, rough = battlefield.wall_squares(field), battlefield.difficult_squares(field)
+    marks: dict[grid.Square, str] = {}
+    legend = []
+    for key, combatant in zip(KEYS, _placed(state), strict=False):
+        for square in battlefield.footprint_of(state, combatant) or []:
+            marks[square] = key
+        side = "party" if battlefield.is_party(combatant) else "foe"
+        size = "" if combatant.size == "medium" else f", {combatant.size}"
+        hidden = ", hidden" if combatant.hidden else ""
+        legend.append(f"{key} {combatant.name} ({side}{size}{hidden}) {combatant.position}")
+    columns = [grid.name((x, 0))[0] for x in range(field.width)]
+    rows = [
+        f"{y + 1:>2} "
+        + " ".join(
+            marks.get((x, y), "#" if (x, y) in walls else "~" if (x, y) in rough else ".")
+            for x in range(field.width)
+        )
+        for y in range(field.height)
+    ]
+    last = grid.name((field.width - 1, field.height - 1))
+    lines = [
+        f"Battle map A1-{last}, 5 ft squares. # wall, ~ difficult terrain.",
+        "   " + " ".join(columns),
+        *rows,
+        "; ".join(legend) or "Nobody on the map yet: the fight's start places everyone.",
+    ]
+    away = [c.name for c in state.initiative_order if c.position is None]
+    if away:
+        lines.append(f"Not on the map: {', '.join(away)} (place_tokens).")
+    return "\n".join(lines)
+
+
+def positions(campaign: Campaign) -> str | None:
+    """Who stands where, and how far the acting combatant is from the others."""
+    state = campaign.game_state
+    placed = _placed(state)
+    if state.battlefield is None or not placed:
+        return None
+    line = "Positions: " + ", ".join(f"{c.name} {c.position}" for c in placed) + "."
+    current = state.current_combatant
+    if current is not None and current.position is not None:
+        line += f" From {current.name}: {nearby(campaign, current)}."
+    return line
+
+
+def nearby(campaign: Campaign, combatant: Combatant) -> str:
+    """The others by distance from *combatant*: "Goblin 1 adjacent, Ogre 30 ft"."""
+    state = campaign.game_state
+    mine = battlefield.footprint_of(state, combatant) or []
+    distances = sorted(
+        (grid.feet_between(mine, held), other.name)
+        for other, held in battlefield.others(state, combatant)
+    )
+    return ", ".join(
+        f"{name} {'adjacent' if feet == grid.FEET else f'{feet} ft'}" for feet, name in distances
+    )
+
+
+def move(campaign: Campaign, done: Move) -> str:
+    """What a move did: where to, what it cost, who may strike, who is near now."""
+    who = done.mover
+    if done.forced:
+        head = f"{who.name} is moved {done.feet} ft, {done.start} to {who.position}"
+        return f"{head} (no movement spent, no opportunity attack). Now: {nearby(campaign, who)}."
+    stood = " stands up and" if done.stood_up else ""
+    text = (
+        f"{who.name}{stood} moves {done.feet} ft, {done.start} to {who.position}; "
+        f"{done.left} ft left this turn."
+    )
+    if done.provoked:
+        text += (
+            f" Leaving their reach provokes opportunity attacks from {', '.join(done.provoked)}."
+        )
+    if done.short_of is not None:
+        target, feet = done.short_of
+        text += f" {target} is still {feet} ft away."
+    return f"{text} Now: {nearby(campaign, who)}."
+
+
+def area(done: Area) -> str:
+    """Who an area of effect catches, the party first."""
+    party = [_named(c) for c in done.caught if battlefield.is_party(c)]
+    foes = [_named(c) for c in done.caught if not battlefield.is_party(c)]
+    if not done.caught:
+        return f"The {done.label} catches no one ({len(done.squares)} squares)."
+    caught = "; ".join(
+        part
+        for part in (
+            f"party: {', '.join(party)}" if party else "",
+            f"foes: {', '.join(foes)}" if foes else "",
+        )
+        if part
+    )
+    return f"The {done.label} catches {caught} ({len(done.squares)} squares)."
+
+
+def sightline(seen: Sightline) -> str:
+    """The facts bearing on an attack, in the order a ruling needs them."""
+    who, at = seen.attacker.name, seen.target.name
+    parts = [f"{who} to {at}: {seen.feet} ft{', within reach' if seen.in_reach else ''}."]
+    if seen.cover == "total":
+        parts.append(f"{at} has total cover: it cannot be targeted directly.")
+    elif seen.cover != "none":
+        bonus = COVER_BONUS[seen.cover]
+        parts.append(f"{at} has {seen.cover} cover: +{bonus} AC and Dexterity saves.")
+    if seen.pressed_by:
+        parts.append(
+            f"{', '.join(seen.pressed_by)} adjacent to {who}: ranged attacks have disadvantage."
+        )
+    if seen.target.hidden:
+        parts.append(f"{at} is hidden: attacks at disadvantage, if {who} guesses the square.")
+    if seen.attacker.hidden:
+        parts.append(f"{who} attacks from hiding: advantage; the attack reveals them.")
+    return " ".join(parts)
+
+
+def _named(combatant: Combatant) -> str:
+    return f"{combatant.name} (hidden)" if combatant.hidden else combatant.name
+
+
+def _placed(state: GameState) -> list[Combatant]:
+    return [c for c in state.initiative_order if c.position is not None]

dndkit/tools/resources.py

@@ -0,0 +1,104 @@
+"""Character resource tools: inventory, death saves and rests."""
+
+from collections.abc import Callable
+from typing import Annotated, Literal
+
+from fastmcp.dependencies import Depends
+from fastmcp.tools import tool
+from pydantic import Field
+
+from dndkit.game import resources, rests
+from dndkit.game.dice import DiceLog
+from dndkit.game.resources import DeathSave
+from dndkit.game.rests import RestKind
+from dndkit.models import Item
+from dndkit.storage import CampaignStore
+from dndkit.tools.deps import NameOrId, get_dice_log, get_store
+
+
+@tool
+def add_item_to_character(
+    character_name_or_id: NameOrId,
+    item_name: Annotated[str, Field(min_length=1, description="Item name")],
+    quantity: Annotated[int, Field(ge=1, description="How many")] = 1,
+    item_type: Annotated[
+        Literal["weapon", "armor", "consumable", "misc"], Field(description="Item type")
+    ] = "misc",
+    description: Annotated[str | None, Field(description="Item description")] = None,
+    weight: Annotated[float | None, Field(ge=0, description="Weight in pounds")] = None,
+    value: Annotated[str | None, Field(description="Value, e.g. '50 gp'")] = None,
+    store: CampaignStore = Depends(get_store),
+) -> str:
+    """Give items to a character. Items already carried stack."""
+    item = Item(
+        name=item_name.strip(),
+        quantity=quantity,
+        item_type=item_type,
+        description=description,
+        weight=weight,
+        value=value,
+    )
+    with store.transaction() as campaign:
+        character, held = resources.add_item(campaign, character_name_or_id, item)
+    return f"{character.name} now carries {held.quantity} x {held.name}."
+
+
+@tool
+def remove_item_from_character(
+    character_name_or_id: NameOrId,
+    item_name: Annotated[str, Field(min_length=1, description="Item name")],
+    quantity: Annotated[int, Field(ge=1, description="How many to remove")] = 1,
+    store: CampaignStore = Depends(get_store),
+) -> str:
+    """Take items away from a character: used, sold, lost or given away."""
+    with store.transaction() as campaign:
+        character, item, left = resources.remove_item(
+            campaign, character_name_or_id, item_name, quantity
+        )
+    return f"{character.name} has {left} x {item.name} left."
+
+
+@tool
+def record_death_save(
+    character_name_or_id: NameOrId,
+    outcome: Annotated[
+        DeathSave,
+        Field(
+            description="success (10+), failure (2-9), nat20 (regain 1 HP), nat1 (two "
+            "failures), stabilized (Spare the Dying, Medicine DC 10)"
+        ),
+    ],
+    store: CampaignStore = Depends(get_store),
+) -> str:
+    """Record a death saving throw for a character at 0 HP."""
+    with store.transaction() as campaign:
+        return resources.record_death_save(campaign, character_name_or_id, outcome)
+
+
+@tool
+def rest(
+    kind: Annotated[RestKind, Field(description="short (1 hour) or long (8 hours)")] = "long",
+    names_or_ids: Annotated[
+        list[str] | None, Field(description="Who rests; omit for the whole party")
+    ] = None,
+    hit_dice: Annotated[
+        int, Field(ge=0, le=20, description="Short rest: Hit Dice each one spends to heal")
+    ] = 0,
+    store: CampaignStore = Depends(get_store),
+    log: DiceLog = Depends(get_dice_log),
+) -> str:
+    """Rest. Long: full HP and slots, half the Hit Dice back, one exhaustion level less.
+    Short: pact slots, and Hit Dice spent heal (rolled here)."""
+    with store.transaction() as campaign:
+        rested = rests.rest(campaign, names_or_ids or [], kind, hit_dice)
+    for roll in rested.rolls:
+        log.record(roll)
+    return "\n".join(rested.lines) or "No characters to rest."
+
+
+TOOLS: list[Callable[..., str]] = [
+    add_item_to_character,
+    remove_item_from_character,
+    record_death_save,
+    rest,
+]