agentshim 0.15.4__tar.gz → 0.15.6__tar.gz

{agentshim-0.15.4 → agentshim-0.15.6}/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.15.6 (2026-10-09)
+
+### Fixed
+
+- A Codex app-server that ignores the interrupt of a timed-out turn is stopped, and the
+  next turn replaces it by resuming the thread, as the Claude stream transport already
+  does. Before, the conversation was written off: the next turn failed with "the previous
+  turn did not stop" and the session then forgot the thread, so one hung turn cost two
+  failed turns and the conversation's history.
+
+## 0.15.5 (2026-10-09)
+
+### Fixed
+
+- A conversation whose provider thread was lost under it is no longer wedged. When a
+  turn that did not itself resume (its conversation was opened during the turn)
+  failed with `SessionResumeError` (the Codex app-server died mid-turn and its thread
+  could not be resumed in the new process), the session kept the dead conversation
+  open and every later turn raised the same error. The session now closes and forgets
+  it, still without replaying the turn that may have run.
+- A Codex app-server that never acknowledges a turn (silent or wedged) is stopped when
+  the turn times out, so the next turn replaces it by resuming the thread instead of
+  timing out against the same process forever. (The Claude stream transport already
+  killed a process that ignored its interrupt.)
+
 ## 0.15.4 (2026-10-09)
 
 ### Added

{agentshim-0.15.4 → agentshim-0.15.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentshim
-Version: 0.15.4
+Version: 0.15.6
 Summary: Provider-agnostic coding-agent CLI shims
 License-Expression: MIT
 License-File: LICENSE

{agentshim-0.15.4 → agentshim-0.15.6}/agentshim/__init__.py

@@ -156,7 +156,7 @@ from .providers.opencode import OpencodeProvider
 from .runtime import Agent
 from .session import Session, Turn, TurnTicket, map_mcp_servers
 
-__version__ = "0.15.4"
+__version__ = "0.15.6"
 
 __all__ = [
     "Agent",

{agentshim-0.15.4 → agentshim-0.15.6}/agentshim/core/session_policy.py

@@ -12,7 +12,9 @@ What the policy decides, per turn:
 * A ``TRANSIENT`` failure is retried in place after each delay of the
   ``RetryPolicy``; the waits end early when the shell reports a stop.
 * A refused resume replaces the conversation once, unless the turn must not
-  lose its conversation (``strict`` or ``pinned``).
+  lose its conversation (``strict`` or ``pinned``). A refusal during a turn that
+  did not itself resume (the conversation was lost under it) forgets the
+  conversation without replaying the turn.
 * An unclassified failure of a resumed turn forgets the conversation.
 * After a successful turn that exhausts the provider's ``RenewalBudget`` the
   conversation is retired.
@@ -531,13 +533,22 @@ class SessionPolicy:
         if event.outcome is Outcome.TRANSIENT:
             return self._retry_transient(state, turn, event)
         if event.outcome is Outcome.RESUME_REFUSED:
-            if turn.resumed and not turn.keeps_conversation:
-                return _replace_conversation(state, turn)
-            return _give_up(state, event.now)
+            return self._on_resume_refused(state, turn, event)
         if event.outcome is Outcome.OTHER and turn.resumed and not turn.keeps_conversation:
             return _forget_conversation(state, event.now)
         return _give_up(state, event.now)
 
+    def _on_resume_refused(self, state: SessionState, turn: TurnState, event: Failed) -> Step:
+        if turn.keeps_conversation:
+            return _give_up(state, event.now)
+        if turn.resumed:
+            return _replace_conversation(state, turn)
+        # The turn began in a conversation it opened itself and the provider
+        # then lost it (a process died mid-turn and its thread could not be
+        # resumed). The turn may have run, so it is not replayed, but the
+        # conversation is gone: holding it would refuse every later turn.
+        return _forget_conversation(state, event.now)
+
     def _retry_transient(self, state: SessionState, turn: TurnState, event: Failed) -> Step:
         delays = self.config.retry.delays
         if turn.retries >= len(delays):

{agentshim-0.15.4 → agentshim-0.15.6}/agentshim/providers/codex/app_server/transport.py

@@ -153,7 +153,7 @@ class CodexAppServerTransport:
     The timeouts are in seconds on *clock*: ``startup_timeout`` bounds the
     handshake, ``close_timeout`` each step of shutting the process down, and
     ``interrupt_grace`` how long an interrupted or timed-out turn may take to
-    wind down before the conversation is written off.
+    wind down before its process is stopped.
     """
 
     # Each argument is an independent documented option of the public constructor.
@@ -369,7 +369,6 @@ class _Conversation:
         self._skills: SkillTracker | None = None
         self._failed_servers: dict[str, str] = {}
         self._deferred_failure: TurnFailedError | None = None
-        self._stuck = False
 
     # -- Conversation protocol
 
@@ -559,9 +558,6 @@ class _Conversation:
             if self._running:
                 msg = "a turn is already running in this conversation"
                 raise SessionStateError(msg)
-            if self._stuck:
-                msg = "the previous turn did not stop, so this conversation cannot take another"
-                raise TurnFailedError(msg, kind=FailureKind.OTHER, detail=msg)
             self._running = True
             self._turn_id = None
             self._interrupt_asked = False
@@ -596,6 +592,12 @@ class _Conversation:
                 self._handle(self._channel.read(deadline), turn)
         except Expired:
             self._wind_down(turn)
+            if turn.turn_id is None:
+                # The server never acknowledged the turn, so it is silent or
+                # wedged and no interrupt can reach it. Stop it: the next turn
+                # replaces the process by resuming the thread, where holding
+                # it would time out every later turn too.
+                _stop(self._channel.process, self._timeouts.close)
             raise TurnTimeoutError(request.timeout or 0.0) from None
         except Gone as gone:
             raise self._gone_error(gone) from None
@@ -853,8 +855,10 @@ class _Conversation:
     def _wind_down(self, turn: _Turn) -> None:
         """Stop a turn that is being abandoned and wait, within bounds, for the server to agree.
 
-        If the server never reports the turn over, the conversation is written
-        off: another ``turn/start`` on it could collide with the one still running.
+        If the server never reports the turn over, the process is stopped:
+        another ``turn/start`` on it could collide with the one still running.
+        The next turn replaces it by resuming the thread, as the Claude stream
+        transport does for a process that ignores its interrupt.
         """
         if turn.turn_id is None or turn.completed is not None:
             return
@@ -865,7 +869,7 @@ class _Conversation:
             while turn.completed is None:
                 self._handle(self._channel.read(deadline), turn)
         except (Expired, Gone, AgentShimError):
-            self._stuck = True
+            _stop(self._channel.process, self._timeouts.close)
 
     # -- finishing
 

{agentshim-0.15.4 → agentshim-0.15.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentshim"
-version = "0.15.4"
+version = "0.15.6"
 description = "Provider-agnostic coding-agent CLI shims"
 readme = "README.md"
 license = "MIT"