[Agent Core] 为 Agent Loop 增加 LLM Hard Cutoff - #161

Adds LLM hard-cutoff support to the Python Agent Loop, including deadline propagation, cancellation, late-response suppression, and provider/test updates.

Changes:

• Propagates remaining_s through providers and wrappers.
• Cancels overdue LLM requests and normalizes deadline outcomes.
• Prevents post-deadline follow-ups and records skipped tools.
• Updates provider contracts and focused tests.

Suppressed comments (5)

py-runtime/src/sztu_code/core/loop.py:1148

• The conclude path has the same orphan-message race: the user instruction is appended before _chat(), but a deadline cancellation returns (False, "") without an assistant message. Since runner persistence writes context.messages after an interrupted run, resuming the session can replay this unmatched conclude prompt. Defer the append until _chat() succeeds or roll it back when RunDeadlineExceeded is caught.

        if context.wall_clock_exceeded():
            context.mark_interrupted(TerminationReason.MAX_WALL_CLOCK_EXCEEDED)
            return (False, "")
        context.messages.append({"role": "user", "content": instruction})

py-runtime/src/sztu_code/core/loop.py:450

• This is the only deadline check before StepStartedEvent, intervention handling, and _admit_request(), all of which can await. If the deadline expires during that work and admission returns block, the later branch still marks TOKEN_BUDGET_EXHAUSTED instead of MAX_WALL_CLOCK_EXCEEDED, so a run that never starts an LLM request gets the wrong terminal reason. Re-check the deadline before non-LLM terminal branches and give the wall-clock reason precedence.

            if context.wall_clock_exceeded():
                context.mark_interrupted(TerminationReason.MAX_WALL_CLOCK_EXCEEDED)
                break

py-runtime/src/sztu_code/core/loop.py:1058

• The deadline check is after the admission.action == "block" early return. If _admit_request() crosses the wall-clock deadline while publishing its admission event, this function returns at the block branch without setting max_wall_clock_exceeded, and the caller then labels the run exceeded_max_steps. Check the deadline before handling the block return so the deadline reason wins.

        if context.wall_clock_exceeded():
            context.mark_interrupted(TerminationReason.MAX_WALL_CLOCK_EXCEEDED)
            return ""

py-runtime/src/sztu_code/core/loop.py:1147

• The same race exists in _conclude: _admit_request() can cross the deadline before this check, then the earlier admission.action == "block" return bypasses the wall-clock status and the caller treats the result as an ordinary max-steps conclusion. Move the deadline check before that early return so max_wall_clock_exceeded remains the terminal reason.

        if context.wall_clock_exceeded():
            context.mark_interrupted(TerminationReason.MAX_WALL_CLOCK_EXCEEDED)
            return (False, "")

py-runtime/src/sztu_code/core/trace/provider.py:78

• When the new outer hard-cutoff cancels this await, execution jumps out before the LLM→CORE record below is emitted, leaving only a CORE→LLM api_call in the trace. The resulting trace cannot distinguish a deadline cutoff from an abrupt provider failure or show cleanup outcome, so the new cancellation path loses the timeout observability expected for this feature. Add an exception/deadline trace record around the inner call while preserving cancellation propagation.

        add_remaining_s(self._inner.chat, inner_kwargs, remaining_s)
        result = await self._inner.chat(
            messages, tool_schemas, bus, run_id, **inner_kwargs

• Files reviewed: 12/12 changed files
• Comments generated: 2
• Review effort level: Lite