codee-agent 0.6.4__tar.gz → 0.6.5__tar.gz

{codee_agent-0.6.4 → codee_agent-0.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codee-agent
-Version: 0.6.4
+Version: 0.6.5
 Summary: A virtual co-worker that picks up Jira and Azure DevOps tasks and solves them with coding agents.
 Keywords: ai,agent,jira,azure-devops,claude-code,github-copilot,codex,automation
 Author: Denis Kibalko

{codee_agent-0.6.4 → codee_agent-0.6.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codee-agent"
-version = "0.6.4"
+version = "0.6.5"
 description = "A virtual co-worker that picks up Jira and Azure DevOps tasks and solves them with coding agents."
 readme = "README.md"
 license = "MIT"

{codee_agent-0.6.4 → codee_agent-0.6.5}/src/codee/admin.py

@@ -101,6 +101,11 @@ class ModelOption(BaseModel):
     name: str
 
 
+class ConversationMessage(BaseModel):
+    role: str
+    content: str
+
+
 class ClaudeAccount(BaseModel):
     """One connected Claude account as the settings page lists it.
 
@@ -356,6 +361,12 @@ class AdminState(rx.State):
     tasks_provider: str = "jira"
     coding_agent: str = "claude_code"
     max_parallel_agents: str = "3"
+    agent_test_open: bool = False
+    agent_test_input: str = ""
+    agent_test_session_id: str = ""
+    agent_test_messages: list[ConversationMessage] = []
+    agent_test_sending: bool = False
+    agent_test_generation: int = 0
     # Whether the executor runs Claude Code on the connected accounts instead
     # of leaving ~/.claude/.credentials.json alone.
     claude_code_rotate_keys: bool = False
@@ -1516,6 +1527,61 @@ class AdminState(rx.State):
         error = self._persist_settings()
         return rx.toast.error(error) if error else rx.toast.success("Settings saved")
 
+    def open_agent_test(self) -> None:
+        self.agent_test_input = ""
+        self.agent_test_session_id = ""
+        self.agent_test_messages = []
+        self.agent_test_sending = False
+        self.agent_test_generation += 1
+        self.agent_test_open = True
+
+    def set_agent_test_open(self, open_: bool) -> None:
+        self.agent_test_open = open_
+        if not open_:
+            self.agent_test_generation += 1
+            self.agent_test_sending = False
+
+    def set_agent_test_input(self, value: str) -> None:
+        self.agent_test_input = value
+
+    @rx.event(background=True)
+    async def send_agent_test_message(self) -> Any:
+        async with self:
+            message = self.agent_test_input.strip()
+            if not message or self.agent_test_sending:
+                return
+            agent = self.coding_agent
+            session_id = self.agent_test_session_id
+            generation = self.agent_test_generation
+            self.agent_test_input = ""
+            self.agent_test_sending = True
+            self.agent_test_messages = [
+                *self.agent_test_messages,
+                ConversationMessage(role="user", content=message),
+            ]
+        try:
+            response, session_id = await asyncio.to_thread(
+                SERVICE.test_agent_conversation,
+                agent,
+                message,
+                session_id,
+            )
+        except Exception as error:
+            async with self:
+                if self.agent_test_generation == generation:
+                    self.agent_test_sending = False
+            yield rx.toast.error(f"The coding agent failed: {error}")
+            return
+        async with self:
+            if self.agent_test_generation != generation:
+                return
+            self.agent_test_session_id = session_id
+            self.agent_test_messages = [
+                *self.agent_test_messages,
+                ConversationMessage(role="assistant", content=response),
+            ]
+            self.agent_test_sending = False
+
 
 ACCENT = "var(--codee-accent)"
 ACCENT_DEEP = "var(--codee-accent-deep)"
@@ -2402,9 +2468,9 @@ def run_row(run: RunRecord) -> rx.Component:
             rx.vstack(rx.hstack(rx.text(run.skill_name, font_weight="600"),
                                 rx.badge(run.status, color_scheme=rx.cond(run.status == "succeeded", "green", "red"))),
                       rx.text(local_datetime(run.started_at), color=MUTED,
-                          font_size="0.8rem",
+                              font_size="0.8rem",
                               font_family="IBM Plex Mono, monospace"),
-                          rx.text("Thread ID: ", run.session_id, color=MUTED,
+                      rx.text("Thread ID: ", run.session_id, color=MUTED,
                               font_size="0.8rem",
                               font_family="IBM Plex Mono, monospace"),
                       rx.text(run.preview, color=MUTED),
@@ -2418,9 +2484,10 @@ def run_row(run: RunRecord) -> rx.Component:
         rx.cond((run.user_message != "") | (run.response != ""), rx.accordion.root(rx.accordion.item(
             header="Run info", content=rx.vstack(
                 rx.text("User message", font_weight="600"),
-            rx.text(run.user_message, white_space="pre-wrap"),
+                rx.text(run.user_message, white_space="pre-wrap"),
                 rx.cond(run.response != "", rx.fragment(
-                    rx.text("LLM response", font_weight="600", margin_top="0.75rem"),
+                    rx.text("LLM response", font_weight="600",
+                            margin_top="0.75rem"),
                     rx.text(run.response, white_space="pre-wrap"))),
                 spacing="2", align="start", width="100%"), value=run.started_at),
             collapsible=True, width="100%")),
@@ -2644,7 +2711,8 @@ def workflow_page() -> rx.Component:
             rx.center(
                 rx.vstack(
                     rx.spinner(size="3"),
-                    rx.foreach(AdminState.workflow_progress, workflow_progress_line),
+                    rx.foreach(AdminState.workflow_progress,
+                               workflow_progress_line),
                     spacing="3",
                     align="center",
                     width="100%",
@@ -3221,6 +3289,64 @@ def claude_code_setting() -> rx.Component:
         padding="1.25rem", background=SURFACE, border=BORDER, width="100%")
 
 
+def conversation_message(message: ConversationMessage) -> rx.Component:
+    is_user = message.role == "user"
+    return rx.box(
+        rx.text(message.content, white_space="pre-wrap"),
+        align_self=rx.cond(is_user, "end", "start"),
+        background=rx.cond(is_user, ACTIVE, SURFACE),
+        border=rx.cond(is_user, "none", BORDER),
+        border_radius="6px",
+        padding="0.65rem 0.8rem",
+        max_width="85%",
+    )
+
+
+def agent_test_dialog() -> rx.Component:
+    return rx.dialog.root(
+        rx.dialog.content(
+            rx.dialog.title("Test conversation"),
+            rx.dialog.description(
+                "Chat with the selected coding agent in the Codee project.",
+                color=MUTED),
+            rx.scroll_area(
+                rx.vstack(
+                    rx.cond(
+                        AdminState.agent_test_messages.length() == 0,
+                        rx.text("Send a message to start the conversation.",
+                                color=MUTED, font_size="0.9rem",
+                                align_self="center", margin_top="3rem"),
+                        rx.foreach(AdminState.agent_test_messages,
+                                   conversation_message)),
+                    width="100%", spacing="3"),
+                type="auto", scrollbars="vertical", height="22rem",
+                width="100%", margin_top="1rem"),
+            rx.form(
+                rx.hstack(
+                    rx.input(
+                        value=AdminState.agent_test_input,
+                        on_change=AdminState.set_agent_test_input,
+                        placeholder="Message the agent",
+                        disabled=AdminState.agent_test_sending,
+                        auto_focus=True,
+                        width="100%"),
+                    rx.button(rx.icon("send", size=16), type="submit",
+                              loading=AdminState.agent_test_sending,
+                              disabled=AdminState.agent_test_input == ""),
+                    spacing="2", width="100%"),
+                on_submit=AdminState.send_agent_test_message,
+                reset_on_submit=False,
+                width="100%", margin_top="1rem"),
+            rx.flex(
+                rx.dialog.close(rx.button("Close", variant="soft",
+                                          color_scheme="gray")),
+                justify="end", margin_top="1rem"),
+            max_width="38rem"),
+        open=AdminState.agent_test_open,
+        on_open_change=AdminState.set_agent_test_open,
+    )
+
+
 def settings_page() -> rx.Component:
     jira = TasksProvider.JIRA
     jira_fields = rx.vstack(
@@ -3248,10 +3374,17 @@ def settings_page() -> rx.Component:
             rx.heading("Coding agent", size="4", margin_bottom="1rem"),
             rx.vstack(
                 field("Default agent",
-                      rx.select(["claude_code", "github_copilot", "codex"],
-                                value=AdminState.coding_agent,
-                                on_change=AdminState.set_coding_agent,
-                                width="100%")),
+                      rx.hstack(
+                          rx.select(
+                              ["claude_code", "github_copilot", "codex"],
+                              value=AdminState.coding_agent,
+                              on_change=AdminState.set_coding_agent,
+                              width="100%"),
+                          rx.button(rx.icon("messages-square", size=16),
+                                    "Test conversation", variant="outline",
+                                    white_space="nowrap",
+                                    on_click=AdminState.open_agent_test),
+                          width="100%", spacing="3")),
                 field("Max parallel tasks",
                       rx.input(value=AdminState.max_parallel_agents,
                                on_change=AdminState.set_max_parallel_agents,
@@ -3277,6 +3410,7 @@ def settings_page() -> rx.Component:
             padding="1.25rem", background=SURFACE, border=BORDER, width="100%"),
         rx.button(rx.icon("save", size=16), "Save settings",
                   on_click=AdminState.save_settings),
+        agent_test_dialog(),
         spacing="5", align="start", width="100%"))
 
 

{codee_agent-0.6.4 → codee_agent-0.6.5}/src/codee/admin_service.py

@@ -192,6 +192,7 @@ class WorkflowGeneration:
     workflow: dict[str, Any] | None = None
     error: str = ""
 
+
 # The checks the settings page runs against the tasks provider, in the order it
 # shows them: the second is only worth attempting once the first passes.
 TASKS_CHECK = "Tasks can be pulled"
@@ -893,7 +894,8 @@ class AdminService:
         # and how long it stands. Shared by every visitor to the dashboard,
         # because it is a property of the accounts rather than of whoever is
         # looking at them.
-        self._usage_cache: dict[int, tuple[ConnectedAccount, float, float]] = {}
+        self._usage_cache: dict[int,
+                                tuple[ConnectedAccount, float, float]] = {}
         self._usage_lock = threading.Lock()
 
     def _git_push(self, message: str) -> tuple[bool, str]:
@@ -1221,7 +1223,8 @@ class AdminService:
         name belongs on the other item's graph, so it is kept out of this one.
         """
         if not skills:
-            report(f"No issue-trigger skills for work item {issue_type.capitalize()}.")
+            report(
+                f"No issue-trigger skills for work item {issue_type.capitalize()}.")
             return {"nodes": [], "edges": [], "warnings": []}
 
         documents = []
@@ -1414,7 +1417,8 @@ class AdminService:
                  for status in (transition["source"], transition["target"])}
         statuses, foreign_statuses = _own_work_item_statuses(
             statuses, scope, triggered | moved,
-            dict.fromkeys(document for _, document in skill_documents.values()),
+            dict.fromkeys(document for _,
+                          document in skill_documents.values()),
         )
         if foreign_statuses:
             report(
@@ -1831,7 +1835,7 @@ class AdminService:
             existing, _ = parse_skill(current_path.read_text())
             extra = {key: value for key, value in existing.items()
                      if key not in MANAGED}
-        action =f"rename {old_slug} -> {name}" if name != old_slug else f"update {name}"
+        action = f"rename {old_slug} -> {name}" if name != old_slug else f"update {name}"
         saved, pushed, message = self._write_and_push(
             current_path,
             build_skill(frontmatter, extra, skill["body"]),
@@ -2439,6 +2443,28 @@ class AdminService:
         except ValueError as exc:
             raise RuntimeError(str(exc)) from exc
 
+    def test_agent_conversation(
+        self, agent_code: str, user_message: str, session_id: str = ""
+    ) -> tuple[str, str]:
+        """Run one turn with the selected agent and return reply plus session id."""
+        selected = resolve_agent_code(agent_code)
+        if selected is None:
+            raise RuntimeError(f"Unsupported coding agent: {agent_code}")
+        agent = build_coding_agent(self.context.settings, self.root, selected)
+        actual_session_id = session_id or str(uuid.uuid4())
+
+        def opened(opened_session_id: str) -> None:
+            nonlocal actual_session_id
+            actual_session_id = opened_session_id
+
+        if session_id:
+            response = agent.continue_conversation(
+                user_message, session_id, on_session_id=opened)
+        else:
+            response = agent.run(
+                user_message, actual_session_id, on_session_id=opened)
+        return response, actual_session_id
+
     def setup_tasks_mcp(
         self,
         tasks_provider: str,
@@ -2600,7 +2626,8 @@ def _format_token_expiry(expires_at: str | None) -> str:
         return "refreshes on next check"
     if deadline.tzinfo is None:
         deadline = deadline.replace(tzinfo=timezone.utc)
-    minutes = int((deadline - datetime.now(timezone.utc)).total_seconds() // 60)
+    minutes = int(
+        (deadline - datetime.now(timezone.utc)).total_seconds() // 60)
     if minutes < 1:
         return "refreshes on next check"
     if minutes < 60:

{codee_agent-0.6.4 → codee_agent-0.6.5}/src/codee/test_admin_service.py

@@ -80,7 +80,8 @@ class NormalizeWorkItemsTest(unittest.TestCase):
             [("story", ["Story"], ""), ("task", ["Task", "Bug"], "")])
 
         self.assertEqual(error, "")
-        self.assertEqual(mapping, {"story": ["Story"], "task": ["Task", "Bug"]})
+        self.assertEqual(
+            mapping, {"story": ["Story"], "task": ["Task", "Bug"]})
 
     def test_a_type_listed_twice_in_one_row_is_kept_once(self) -> None:
         mapping, _, error = normalize_work_items(
@@ -164,6 +165,42 @@ class NormalizeWorkItemsTest(unittest.TestCase):
         self.assertEqual(error, "'bug' is listed twice")
 
 
+class TestAgentConversationTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.service = AdminService.__new__(AdminService)
+        self.service.root = Path("/repo")
+        self.service.context = Mock(settings=Settings())
+
+    @patch("codee.admin_service.build_coding_agent")
+    def test_first_turn_returns_the_agent_session_id(self, build_agent) -> None:
+        agent = build_agent.return_value
+
+        def run(message, session_id, model="", on_session_id=None):
+            on_session_id("agent-thread")
+            return "Final response"
+
+        agent.run.side_effect = run
+
+        response, session_id = self.service.test_agent_conversation(
+            "codex", "Hello")
+
+        self.assertEqual(response, "Final response")
+        self.assertEqual(session_id, "agent-thread")
+        build_agent.assert_called_once_with(
+            self.service.context.settings, Path("/repo"), CodingAgent.CODEX)
+
+    @patch("codee.admin_service.build_coding_agent")
+    def test_later_turn_resumes_the_same_session(self, build_agent) -> None:
+        build_agent.return_value.continue_conversation.return_value = "Still here"
+
+        response, session_id = self.service.test_agent_conversation(
+            "github_copilot", "What did I ask?", "same-thread")
+
+        self.assertEqual((response, session_id), ("Still here", "same-thread"))
+        call = build_agent.return_value.continue_conversation.call_args
+        self.assertEqual(call.args[:2], ("What did I ask?", "same-thread"))
+
+
 class AdminServiceWorkItemsTest(unittest.TestCase):
     def _service(self, directory: Path) -> AdminService:
         service = AdminService.__new__(AdminService)
@@ -408,7 +445,8 @@ class AdminServiceClaudeCodeAccountsTest(unittest.TestCase):
         self._connect("one@example.com")
         self._connect("two@example.com")
         second = self.service.claude_code_accounts()[1]
-        claude_code_accounts.set_current_account(second.id, self.service.context)
+        claude_code_accounts.set_current_account(
+            second.id, self.service.context)
 
         self.service.disconnect_claude_code_account(second.id)
 
@@ -423,7 +461,8 @@ class AdminServiceClaudeCodeAccountsTest(unittest.TestCase):
 
         self.service.disconnect_claude_code_account(account.id)
 
-        self.assertEqual(claude_code_accounts.accounts(self.service.context), [])
+        self.assertEqual(claude_code_accounts.accounts(
+            self.service.context), [])
 
     def test_switching_rotation_off_forgets_which_account_is_in_use(self) -> None:
         # So switching it back on later starts from the top rather than from
@@ -431,7 +470,8 @@ class AdminServiceClaudeCodeAccountsTest(unittest.TestCase):
         self._connect("one@example.com")
         self._connect("two@example.com")
         second = self.service.claude_code_accounts()[1]
-        claude_code_accounts.set_current_account(second.id, self.service.context)
+        claude_code_accounts.set_current_account(
+            second.id, self.service.context)
 
         self.service.save_settings("jira", "claude_code", 3, {}, None, None,
                                    "", False)
@@ -465,14 +505,16 @@ class AdminServiceClaudeCodeAccountsTest(unittest.TestCase):
             "access-1", "refresh-1", expires_at=far_future,
             refresh_expires_at=far_future))
 
-        self.assertFalse(self.service.claude_code_accounts()[0].needs_reconnect)
+        self.assertFalse(self.service.claude_code_accounts()
+                         [0].needs_reconnect)
 
     def test_an_account_with_no_known_window_is_not_flagged(self) -> None:
         # Zero means the API never said, which is not the same as expired.
         self._connect("one@example.com", tokens=claude_oauth.Tokens(
             "access-1", "refresh-1", expires_at=1, refresh_expires_at=0))
 
-        self.assertFalse(self.service.claude_code_accounts()[0].needs_reconnect)
+        self.assertFalse(self.service.claude_code_accounts()
+                         [0].needs_reconnect)
 
     def test_each_account_reports_both_of_its_windows(self) -> None:
         self._connect("one@example.com")
@@ -487,7 +529,8 @@ class AdminServiceClaudeCodeAccountsTest(unittest.TestCase):
 
         self.assertEqual(measured[0].session_percent, 12.0)
         self.assertEqual(measured[0].weekly_percent, 70.0)
-        self.assertEqual(measured[0].weekly_resets, "2026-09-16T09:00:00+00:00")
+        self.assertEqual(measured[0].weekly_resets,
+                         "2026-09-16T09:00:00+00:00")
         self.assertEqual(measured[0].usage_error, "")
 
     def test_the_reading_is_cached_rather_than_taken_every_redraw(self) -> None:
@@ -555,7 +598,8 @@ class AdminServiceClaudeCodeAccountsTest(unittest.TestCase):
                 measured[1].id, self.service.context)
             again = self.service.claude_code_account_usage()
 
-        self.assertEqual([account.in_use for account in measured], [True, False])
+        self.assertEqual(
+            [account.in_use for account in measured], [True, False])
         self.assertEqual([account.in_use for account in again], [False, True])
         self.assertEqual(again[1].session_percent, 3.0)
 
@@ -594,7 +638,8 @@ class AdminServiceClaudeCodeAccountsTest(unittest.TestCase):
 
         self.assertEqual(measured[0].session_percent, 12.0)
         self.assertEqual(measured[0].weekly_percent, 70.0)
-        self.assertEqual(measured[0].session_resets, "2026-09-13T14:10:00+00:00")
+        self.assertEqual(measured[0].session_resets,
+                         "2026-09-13T14:10:00+00:00")
         self.assertEqual(measured[0].usage_error, "")
 
     def test_a_rate_limit_with_nothing_to_fall_back_on_says_so(self) -> None:
@@ -662,7 +707,8 @@ class AdminServiceClaudeCodeAccountsTest(unittest.TestCase):
                       return_value=Usage(limited=False, windows={}, resets_at={})):
             measured = self.service.claude_code_account_usage()
 
-        self.assertEqual([account.in_use for account in measured], [True, False])
+        self.assertEqual(
+            [account.in_use for account in measured], [True, False])
 
     def test_no_accounts_means_no_requests(self) -> None:
         with patch("codee.admin_service.fetch_usage") as fetch:
@@ -1927,7 +1973,6 @@ class AdminServiceIssueTriggerTest(unittest.TestCase):
 
             self.assertEqual(generate.call_count, 1)
 
-
     def test_generate_workflow_regenerates_a_graph_from_an_older_version(self) -> None:
         with tempfile.TemporaryDirectory() as temporary_directory:
             root = Path(temporary_directory)
@@ -2046,7 +2091,8 @@ class AdminServiceWorkflowAgentTest(unittest.TestCase):
 
             nodes = self._story_nodes(service)
 
-            self.assertNotIn("workflow-node--agent", nodes["Review"]["className"])
+            self.assertNotIn("workflow-node--agent",
+                             nodes["Review"]["className"])
             self.assertNotIn("style", nodes["Review"])
 
     def test_changing_the_agent_needs_no_second_inference(self) -> None:
@@ -2491,7 +2537,8 @@ class AdminServiceAgentModelsTest(unittest.TestCase):
                 patch.object(ClaudeCodeAgent, "list_models") as claude_models:
             models = service.list_agent_models("codex")
 
-        self.assertEqual(models, [{"id": "gpt-6-astra", "name": "GPT-6 Astra"}])
+        self.assertEqual(
+            models, [{"id": "gpt-6-astra", "name": "GPT-6 Astra"}])
         claude_models.assert_not_called()
 
     def test_an_agent_codee_cannot_run_falls_back_to_the_default(self) -> None:

{codee_agent-0.6.4 → codee_agent-0.6.5}/src/codee_agent_abstract/provider.py

@@ -69,6 +69,21 @@ class AbstractCodingAgent(ABC):
         """
         ...
 
+    def continue_conversation(
+        self,
+        user_message: str,
+        session_id: str,
+        model: str = "",
+        on_session_id: Callable[[str], None] | None = None,
+    ) -> str:
+        """Continue an existing agent conversation and return its final reply.
+
+        Agents whose normal run command resumes when given an existing session
+        need no special implementation. Agents with a distinct resume command
+        override this method.
+        """
+        return self.run(user_message, session_id, model, on_session_id)
+
     def skill_prompt(self, slug: str, path: Path, argument: str = "",
                      argument_name: str = "") -> str:
         """The message that makes this agent run the skill stored at ``path``.

{codee_agent-0.6.4 → codee_agent-0.6.5}/src/codee_agent_claude_code/provider.py

@@ -58,10 +58,25 @@ class ClaudeCodeAgent(AbstractCodingAgent):
         # answer is known before the run starts.
         if on_session_id:
             on_session_id(session_id)
+        return self._run(user_message, session_id, model, False)
+
+    def continue_conversation(
+        self,
+        user_message: str,
+        session_id: str,
+        model: str = "",
+        on_session_id: Callable[[str], None] | None = None,
+    ) -> str:
+        if on_session_id:
+            on_session_id(session_id)
+        return self._run(user_message, session_id, model, True)
+
+    def _run(self, user_message: str, session_id: str, model: str,
+             resume: bool) -> str:
         cmd = [
             self.CLI_COMMAND,
             "-p", user_message,
-            "--session-id", session_id,
+            "--resume" if resume else "--session-id", session_id,
             "--max-budget-usd", self.MAX_BUDGET_USD,
             "--output-format", "json",
             "--permission-mode", "bypassPermissions",
@@ -91,7 +106,7 @@ class ClaudeCodeAgent(AbstractCodingAgent):
         stdout = result.stdout or ""
         stderr = result.stderr or ""
         log.debug("claude exited %d (%d bytes stdout, %d bytes stderr)",
-              result.returncode, len(stdout), len(stderr))
+                  result.returncode, len(stdout), len(stderr))
 
         # Raise on any non-success so callers retry. Over-limit exits non-zero;
         # a completed-but-errored run sets is_error in the JSON.

{codee_agent-0.6.4 → codee_agent-0.6.5}/src/codee_agent_claude_code/test.py

@@ -34,7 +34,8 @@ def _response(status_code: int, text: str = "", json_body=None):
     response = Mock(spec=["status_code", "text", "json"])
     response.status_code = status_code
     response.text = text
-    response.json = Mock(return_value=json_body if json_body is not None else {})
+    response.json = Mock(
+        return_value=json_body if json_body is not None else {})
     return response
 
 
@@ -56,6 +57,14 @@ class ClaudeCodeRunTest(unittest.TestCase):
 
         self.assertEqual(cmd[cmd.index("--model") + 1], "opus")
 
+    def test_continuing_uses_resume_instead_of_starting_a_session(self) -> None:
+        with patch("subprocess.run", return_value=_completed()) as run:
+            self.agent.continue_conversation("And now?", SESSION)
+
+        cmd = run.call_args.args[0]
+        self.assertEqual(cmd[cmd.index("--resume") + 1], SESSION)
+        self.assertNotIn("--session-id", cmd)
+
     def test_cli_output_is_decoded_as_utf8(self) -> None:
         with patch("subprocess.run", return_value=_completed()) as run:
             self.agent.run("/do-it CORE-1", SESSION)
@@ -129,7 +138,8 @@ class ClaudeCodeUsageTest(unittest.TestCase):
         # the executor to a key by looking like an error.
         self.assertFalse(read_usage({}).limited)
         self.assertFalse(read_usage({"five_hour": None}).limited)
-        self.assertFalse(read_usage({"five_hour": {"utilization": None}}).limited)
+        self.assertFalse(read_usage(
+            {"five_hour": {"utilization": None}}).limited)
 
     def test_a_rejected_key_counts_as_spent(self) -> None:
         # Expired or revoked. As unusable as an exhausted one, and the same

{codee_agent-0.6.4 → codee_agent-0.6.5}/src/codee_agent_codex/provider.py

@@ -101,12 +101,36 @@ class CodexAgent(AbstractCodingAgent):
                 f"Codex run produced no response: {_detail(errors, result.stderr)}")
         return reply
 
+    def continue_conversation(
+        self,
+        user_message: str,
+        session_id: str,
+        model: str = "",
+        on_session_id: Callable[[str], None] | None = None,
+    ) -> str:
+        result = self._exec(user_message, model, on_session_id, session_id)
+        reply, completed, errors = _parse_events(result.stdout)
+        if result.returncode != 0:
+            raise RuntimeError(
+                f"Codex CLI exited {result.returncode}: "
+                f"{_detail(errors, result.stderr)}"
+            )
+        if not completed:
+            raise RuntimeError(
+                f"Codex run errored: {_detail(errors, result.stderr)}")
+        if not reply:
+            raise RuntimeError(
+                f"Codex run produced no response: {_detail(errors, result.stderr)}")
+        return reply
+
     def _exec(self, user_message: str, model: str,
-              on_session_id: Callable[[str], None] | None = None
+              on_session_id: Callable[[str], None] | None = None,
+              resume_session_id: str = "",
               ) -> subprocess.CompletedProcess:
         """One headless ``codex exec`` in a thread of its own."""
         cmd = [
-            self.CLI_COMMAND, "exec",
+            self.CLI_COMMAND, "exec", *
+            (["resume"] if resume_session_id else []),
             "--json",
             # Codee's project root is a repository in the normal case but need
             # not be one, and `codex exec` refuses to start outside git.
@@ -124,7 +148,10 @@ class CodexAgent(AbstractCodingAgent):
         cmd += _mcp_overrides(self._cwd)
         # The prompt goes last, behind `--`, so a skill whose slug collides with
         # a subcommand (`codex exec review`) still reaches the model.
-        cmd += ["--", user_message]
+        cmd += ["--"]
+        if resume_session_id:
+            cmd += [resume_session_id]
+        cmd += [user_message]
 
         log.debug("cwd=%s cmd=%s", self._cwd, " ".join(cmd))
         # Streamed rather than collected at the end: the thread id is on the

{codee_agent-0.6.4 → codee_agent-0.6.5}/src/codee_agent_codex/test.py

@@ -105,6 +105,15 @@ class CodexRunTest(unittest.TestCase):
         self.assertNotIn(SESSION, self._cmd())
         self.assertNotIn("resume", self._cmd())
 
+    def test_continuing_resumes_the_thread(self) -> None:
+        with patch("subprocess.Popen", return_value=_completed(_turn())) as popen:
+            response = self.agent.continue_conversation("And now?", THREAD)
+
+        self.assertEqual(response, "Done, PR is up.")
+        cmd = popen.call_args.args[0]
+        self.assertEqual(cmd[:3], ["codex", "exec", "resume"])
+        self.assertEqual(cmd[-3:], ["--", THREAD, "And now?"])
+
     def test_the_thread_codex_opened_is_reported_back(self) -> None:
         # What the dashboard links its session viewer to while the run is live.
         self._run(_completed(_turn()))

{codee_agent-0.6.4 → codee_agent-0.6.5}/src/codee_agent_github_copilot/test.py

@@ -65,7 +65,8 @@ class CopilotSkillPromptTest(unittest.TestCase):
         )
 
     def test_a_skill_outside_the_working_directory_keeps_its_full_path(self) -> None:
-        prompt = self._prompt(Path("/elsewhere/skills/reviewer/SKILL.md"), "7", "ID")
+        prompt = self._prompt(
+            Path("/elsewhere/skills/reviewer/SKILL.md"), "7", "ID")
 
         self.assertEqual(
             prompt,
@@ -85,7 +86,8 @@ class CopilotRunTest(unittest.TestCase):
 
     def test_returns_the_last_assistant_message(self) -> None:
         stdout = _stream(
-            _event("assistant.message", {"content": "Looking at it", "toolRequests": [{}]}),
+            _event("assistant.message", {
+                   "content": "Looking at it", "toolRequests": [{}]}),
             _event("tool.execution_complete", {}),
             _event("assistant.message", {"content": "Done, PR is up.\n"}),
             _event("result", exitCode=0, sessionId=SESSION),
@@ -119,6 +121,15 @@ class CopilotRunTest(unittest.TestCase):
         self.assertEqual(self.captured.call_args.kwargs["encoding"], "utf-8")
         self.assertEqual(self.captured.call_args.kwargs["errors"], "replace")
 
+    def test_continuing_reuses_the_same_session_id(self) -> None:
+        stdout = _stream(_event("assistant.message", {"content": "ok"}),
+                         _event("result", exitCode=0))
+        with patch("subprocess.run", return_value=_completed(stdout)) as run:
+            self.agent.continue_conversation("And now?", SESSION)
+
+        cmd = run.call_args.args[0]
+        self.assertEqual(cmd[cmd.index("--session-id") + 1], SESSION)
+
     def test_missing_captured_streams_do_not_raise_type_error(self) -> None:
         completed = subprocess.CompletedProcess(
             args=["copilot"], returncode=0, stdout=None, stderr=None)
@@ -159,7 +170,8 @@ class CopilotRunTest(unittest.TestCase):
 
     def test_a_failed_run_raises_with_the_session_error(self) -> None:
         stdout = _stream(
-            _event("session.error", {"errorType": "quota", "message": "quota exceeded"}),
+            _event("session.error", {
+                   "errorType": "quota", "message": "quota exceeded"}),
             _event("result", exitCode=1),
         )
 
@@ -193,7 +205,8 @@ class CopilotCreditCapTest(unittest.TestCase):
             else:
                 os.environ[MAX_AI_CREDITS_ENV_VAR] = value
             with patch("subprocess.run", return_value=_completed(stdout)) as run:
-                GitHubCopilotAgent(Settings(), Path("/repo")).run("/do-it", SESSION)
+                GitHubCopilotAgent(Settings(), Path(
+                    "/repo")).run("/do-it", SESSION)
         cmd = run.call_args.args[0]
         return cmd[cmd.index("--max-ai-credits") + 1]
 
@@ -222,9 +235,12 @@ class CopilotModelCatalogTest(unittest.TestCase):
 
     def test_reads_the_session_new_result_past_other_traffic(self) -> None:
         lines = self._queue(
-            json.dumps({"jsonrpc": "2.0", "id": 1, "result": {"protocolVersion": 1}}),
-            json.dumps({"jsonrpc": "2.0", "method": "session/update", "params": {}}),
-            json.dumps({"jsonrpc": "2.0", "id": 2, "result": {"sessionId": "s1"}}),
+            json.dumps({"jsonrpc": "2.0", "id": 1,
+                       "result": {"protocolVersion": 1}}),
+            json.dumps(
+                {"jsonrpc": "2.0", "method": "session/update", "params": {}}),
+            json.dumps({"jsonrpc": "2.0", "id": 2,
+                       "result": {"sessionId": "s1"}}),
         )
 
         result = _await_result(Mock(poll=Mock(return_value=None)), lines, 2)
@@ -243,7 +259,8 @@ class CopilotModelCatalogTest(unittest.TestCase):
     def test_a_catalog_becomes_id_and_name_pairs(self) -> None:
         result = {"models": {"availableModels": [
             {"modelId": "claude-opus-5", "name": "Claude Opus 5"},
-            {"modelId": "gpt-5.4"},          # no display name: falls back to the id
+            # no display name: falls back to the id
+            {"modelId": "gpt-5.4"},
             {"name": "nameless"},            # no id at all: unusable, skipped
         ]}}