66 lines
4.2 KiB
Python
66 lines
4.2 KiB
Python
"""A worker's prompts: those the entry point driving the cycle words, and those that resume a worker with an answer to its question.
|
|
|
|
An entry point is a tool that drives cycles, such as loop-claude. It words the prompts of its own workflow and names the files of its project. WorkerPrompts holds those, so the cycle doesn't import an entry point to word a prompt.
|
|
"""
|
|
import dataclasses
|
|
import re
|
|
import typing
|
|
|
|
from model_routing.ladder import ProjectRung
|
|
from model_routing.route import Route
|
|
from claude_code.transcript import Typed
|
|
|
|
# Opens typed's prompt, with the answer on the line after it, so typed_answer finds the answer at the prompt's start, whatever the question holds.
|
|
TYPED_HERE = "The human answered your question at {driver}'s terminal:"
|
|
# Finds TYPED_HERE whatever the driver, so a transcript reads the same to every tool that renders it.
|
|
TYPED_OPENING = re.compile(re.escape(TYPED_HERE).replace(re.escape("{driver}"), r"[\w-]+") + "\n")
|
|
|
|
|
|
def answers_recorded(destinations: str) -> str:
|
|
"""What a chunk owes each answer the human typed, before it is finished. destinations names where an answer may be recorded."""
|
|
return f"every answer the human typed in it that a later chunk could need is recorded in {destinations} at the one place it governs"
|
|
|
|
|
|
def typed_answer(prompt: str) -> Typed | None:
|
|
"""Splits a prompt from WorkerPrompts.typed into its answer and the rest, so the judge reads the answer as the human's; None for any other prompt."""
|
|
opening = TYPED_OPENING.match(prompt)
|
|
if not opening:
|
|
return None
|
|
answer, _, rest = prompt[opening.end():].partition("\n\n")
|
|
return Typed(rest, answer)
|
|
|
|
|
|
@dataclasses.dataclass(frozen=True)
|
|
class WorkerPrompts:
|
|
"""What an entry point supplies to the prompts of its cycles."""
|
|
# The entry point's name as the worker, the judge and the human read it, such as `do-epic`.
|
|
driver: str
|
|
# The prompt that starts a worker, from its task, the premises, its route, the project's rung and the facts found before the cycle.
|
|
fresh: typing.Callable[[str, str, Route, ProjectRung | None, str], str]
|
|
# The prompt that resumes a worker whose previous run ended before the chunk was finished, from the evidence of the unfinished verdict, if there was one.
|
|
resumed: typing.Callable[[str, Route, ProjectRung | None], str]
|
|
# The sentences that depend on the worker's rung, each after a space, to follow the sentence a prompt ends on.
|
|
rungs_held: typing.Callable[[Route, ProjectRung | None], str]
|
|
# Where the judge may quote an answer from, named as the human and the worker see them.
|
|
quote_sources: str
|
|
# Where the worker may record an answer the human typed.
|
|
answer_destinations: str
|
|
# What the records the judge reads are, in the order it reads them.
|
|
records_named: str
|
|
|
|
def answered(self, question: str, answer: str, route: Route, project: ProjectRung | None, stepped: bool) -> str:
|
|
"""stepped is whether the answer's ruling stepped the worker up."""
|
|
return f"Your question: {question}\n\n{self.quote_sources} answers it:\n\n{answer}\n\nContinue the task.{self.stepped_to(route, project, stepped)}"
|
|
|
|
def typed(self, question: str, answer: str, route: Route, project: ProjectRung | None, stepped: bool) -> str:
|
|
"""The prompt that resumes the worker with the human's answer to an interrupt. answer is one line, as the terminal reads it."""
|
|
return f"{TYPED_HERE.format(driver=self.driver)}\n{answer}\n\nYour question was: {question}\n\nContinue the task. The chunk is finished only once {answers_recorded(self.answer_destinations)}.{self.stepped_to(route, project, stepped)}"
|
|
|
|
def stepped_to(self, route: Route, project: ProjectRung | None, stepped: bool) -> str:
|
|
"""The sentences naming the worker's new rung, as resumed has them, where the ruling that brought the answer stepped the worker up; empty otherwise."""
|
|
return f" Your request for a higher rung went through: {self.driver} runs you on {route.rung}. The escalation triggers that fired before this step are spent.{self.rungs_held(route, project)}" if stepped else ""
|
|
|
|
def past_the_cap(self, question: str, answer: str, cap: int) -> str:
|
|
"""The question a quoted answer puts to the human once the cycle's quoted answers reach the cap."""
|
|
return f"{question}\n\n{self.quote_sources} says:\n{answer}\n\nThose files have answered {cap} questions this cycle, the most allowed, so this one comes to you."
|