`f2c9862`

Adopt runtime context for response policy helpers

Authored by

espadonne 1 month ago

SHA: f2c9862fa68bd6e7c04d3fb01847b5f4ff1c6f86
Parents: 825fa06
Tree: b69d0c2

4 changed files

Status	File	+	-
M	`src/loader/runtime/completion_policy.py`	8	7
M	`src/loader/runtime/conversation.py`	3	3
M	`src/loader/runtime/repair.py`	8	12
M	`src/loader/runtime/turn_completion.py`	6	5

src/loader/runtime/completion_policy.pymodified

  from dataclasses import dataclass
  from ..llm.base import Message, Role
 +from .context import RuntimeContext
  from .events import AgentEvent, TurnSummary
  from .reasoning_types import TaskCompletionCheck
  from .task_completion import detect_premature_completion, get_continuation_prompt
  class CompletionPolicy:
      """Owns loop bailout, non-mutating completion nudges, and response cleanup."""
 -    def __init__(self, agent) -> None:
 -        self.agent = agent
 +    def __init__(self, context: RuntimeContext) -> None:
 +        self.context = context
      async def maybe_stop_for_text_loop(
          self,
      ) -> TextLoopDecision:
          """Stop the turn when the assistant starts repeating textually."""
 -        is_text_loop, loop_description = self.agent.safeguards.detect_text_loop(content)
 +        is_text_loop, loop_description = self.context.safeguards.detect_text_loop(content)
          if not is_text_loop:
              return TextLoopDecision(should_stop=False)
          summary.final_response = final_response
          summary.failures.append(loop_description)
          final_message = Message(role=Role.ASSISTANT, content=final_response)
 -        self.agent.session.append(final_message)
 +        self.context.session.append(final_message)
          summary.assistant_messages.append(final_message)
          await emit(
              AgentEvent(
      ) -> ContinuationDecision:
          """Nudge non-mutating tasks to continue when completion looks premature."""
 -        cfg = self.agent.config.reasoning
 +        cfg = self.context.config.reasoning
          if continuation_count >= cfg.max_continuation_prompts:
              return ContinuationDecision(should_continue=False)
                  ),
+             )
+         )
 -        self.agent.session.append(Message(role=Role.ASSISTANT, content=response_content))
 -        self.agent.session.append(Message(role=Role.USER, content=continuation_prompt))
 +        self.context.session.append(Message(role=Role.ASSISTANT, content=response_content))
 +        self.context.session.append(Message(role=Role.USER, content=continuation_prompt))
          return ContinuationDecision(should_continue=True)
      @staticmethod

src/loader/runtime/conversation.pymodified

              append_timeline=self.workflow_state.append_timeline_from_decision,
              append_execute_bridge=self.workflow_state.maybe_append_execute_bridge,
+         )
 -        self.repairer = ResponseRepairer(agent)
 -        self.completion_policy = CompletionPolicy(agent)
 +        self.repairer = ResponseRepairer(self.context)
 +        self.completion_policy = CompletionPolicy(self.context)
          self.phase_tracker = TurnPhaseTracker(self.context, self.tracer)
          self.finalizer = TurnFinalizer(
              agent,
              self.workflow_state.set_workflow_mode,
+         )
          self.turn_completion = TurnCompletionController(
 -            agent,
 +            self.context,
              repairer=self.repairer,
              completion_policy=self.completion_policy,
              finalizer=self.finalizer,

src/loader/runtime/repair.pymodified

  from dataclasses import dataclass, field
  from ..llm.base import ToolCall
 +from .context import RuntimeContext
  from .parsing import parse_tool_calls
  class ResponseRepairer:
      """Owns response-repair heuristics that used to live inline in the loop."""
 -    def __init__(self, agent) -> None:
 -        self.agent = agent
 +    def __init__(self, context: RuntimeContext) -> None:
 +        self.context = context
      def handle_empty_response(
          self,
          normalized_tool_calls = list(tool_calls)
          tool_source = "native"
 -        if self.agent.use_react:
 +        if self.context.use_react:
              parsed = parse_tool_calls(content)
              normalized_tool_calls = parsed.tool_calls
              normalized_content = parsed.content
+         )
      def _extract_raw_tool_calls(self, response_content: str) -> list[ToolCall]:
 -        """Recover raw-text tool calls for either agent or RuntimeContext callers."""
 +        """Recover raw-text tool calls from the runtime parser and registry."""
 -        extractor = getattr(self.agent, "_extract_raw_json_tool_calls", None)
 -        if callable(extractor):
 -            return extractor(response_content)
+-
 -        registry = getattr(self.agent, "registry", None)
 -        allowed_tool_names = None
 -        if registry is not None:
 -            allowed_tool_names = [tool.name for tool in registry.list_tools()]
 +        allowed_tool_names = [
 +            tool.name for tool in self.context.registry.list_tools()
 +        ]
          parsed = parse_tool_calls(
              response_content,
              allowed_tool_names=allowed_tool_names,

src/loader/runtime/turn_completion.pymodified

  from ..llm.base import Message, Role
  from .completion_policy import CompletionPolicy
 +from .context import RuntimeContext
  from .dod import DefinitionOfDone
  from .events import AgentEvent, TurnSummary
  from .executor import ToolExecutor
      def __init__(
          self,
 -        agent,
 +        context: RuntimeContext,
          *,
          repairer: ResponseRepairer,
          completion_policy: CompletionPolicy,
          finalizer: TurnFinalizer,
          phase_tracker: TurnPhaseTracker,
      ) -> None:
 -        self.agent = agent
 +        self.context = context
          self.repairer = repairer
          self.completion_policy = completion_policy
          self.finalizer = finalizer
                  finalize_reason_summary="Finalizing after text-loop bailout",
+             )
 -        cfg = self.agent.config.reasoning
 -        self.agent.safeguards.record_response(content)
 +        cfg = self.context.config.reasoning
 +        self.context.safeguards.record_response(content)
          if (
              cfg.completion_check
              and not dod.mutating_actions
+         )
          final_message = Message(role=Role.ASSISTANT, content=response_content)
 -        self.agent.session.append(final_message)
 +        self.context.session.append(final_message)
          summary.assistant_messages.append(final_message)
          gate_result = await self.finalizer.run_definition_of_done_gate(