ttasks 0.3.1__tar.gz → 0.4.0__tar.gz

{ttasks-0.3.1 → ttasks-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ttasks
-Version: 0.3.1
+Version: 0.4.0
 Summary: Add your description here
 Requires-Python: >=3.12
 Requires-Dist: github-copilot-sdk>=0.1.0

{ttasks-0.3.1 → ttasks-0.4.0}/docs/quickstart.md

@@ -19,6 +19,26 @@ assert task.result is result
 and Copilot agent tasks. You can override any handler or create an executor with
 no defaults by using `TaskExecutor.empty()`.
 
+## Share a Copilot agent session
+
+The default Copilot agent handler creates a fresh Copilot session for each task.
+Use `CopilotAgentSession` when multiple `Task.agent(...)` tasks should share one
+conversation:
+
+```python
+from ttasks import CopilotAgentSession, Task, TaskExecutor, TaskType
+
+with CopilotAgentSession(working_directory="/path/to/repo") as agent:
+    executor = TaskExecutor()
+    executor.register(TaskType.AGENT, agent.handler())
+
+    executor.execute(Task.agent("Create a first change."))
+    executor.execute(Task.agent("Continue from the previous change."))
+```
+
+Shared sessions preserve conversation state across agent tasks. The handler
+serializes turns through the session, including when used by `TaskGraph`.
+
 ## Run a graph
 
 ```python

{ttasks-0.3.1 → ttasks-0.4.0}/src/ttasks/__init__.py

@@ -20,12 +20,14 @@ from ._store import (
     Store,
 )
 from ._task import Task, TaskResult, TaskStatus, TaskType
+from .copilot import CopilotAgentSession
 
 __all__ = [
     "EventBus",
     "InMemoryStore",
     "SQLiteStore",
     "Store",
+    "CopilotAgentSession",
     "RetryPolicy",
     "Task",
     "TaskCancelled",

{ttasks-0.3.1 → ttasks-0.4.0}/src/ttasks/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.3.1'
-__version_tuple__ = version_tuple = (0, 3, 1)
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)
 
 __commit_id__ = commit_id = None

ttasks-0.4.0/src/ttasks/copilot.py

@@ -0,0 +1,329 @@
+"""Copilot-backed task handlers and session helpers."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from concurrent.futures import CancelledError as FutureCancelledError
+from concurrent.futures import TimeoutError as FutureTimeoutError
+from threading import Event, Lock, Thread
+from typing import Any, Self
+
+from ._exceptions import TaskCancelled
+from ._executor import DEFAULT_COPILOT_AGENT_MODEL, TaskContext, TaskHandler
+
+
+class CopilotAgentSession:
+    """Long-lived Copilot agent session with a ``TaskExecutor`` handler.
+
+    A shared session preserves Copilot conversation state across multiple
+    ``Task.agent(...)`` executions. Use a fresh ``CopilotAgentSession`` for an
+    independent conversational lane.
+    """
+
+    def __init__(
+        self,
+        *,
+        model: str = DEFAULT_COPILOT_AGENT_MODEL,
+        reasoning_effort: str | None = None,
+        working_directory: str | None = None,
+        timeout: float | None = None,
+        on_event: Callable[[Any], None] | None = None,
+        **session_options: Any,
+    ) -> None:
+        """Configure a reusable Copilot agent session.
+
+        ``session_options`` are passed through to
+        ``CopilotClient.create_session(...)``. Permission requests default to
+        ``PermissionHandler.approve_all`` to match the existing one-shot AGENT
+        handler unless ``on_permission_request`` is supplied.
+        """
+        if not model:
+            raise ValueError("model must not be empty")
+        if timeout is not None and timeout <= 0:
+            raise ValueError("timeout must be greater than 0")
+
+        self.model = model
+        self.reasoning_effort = reasoning_effort
+        self.working_directory = working_directory
+        self.timeout = timeout
+        self._session_options = dict(session_options)
+
+        self._event_handlers: list[Callable[[Any], None]] = []
+        self.event_errors: list[BaseException] = []
+        self._event_lock = Lock()
+        if on_event is not None:
+            self._event_handlers.append(on_event)
+
+        self._client: Any | None = None
+        self._session: Any | None = None
+        self._send_lock: asyncio.Lock | None = None
+        self._active = False
+        self._sync_active = False
+
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._thread: Thread | None = None
+        self._thread_ready = Event()
+        self._handler_lock = Lock()
+
+    async def __aenter__(self) -> Self:
+        """Open the Copilot client and session in the current event loop."""
+        if self._active:
+            raise RuntimeError("CopilotAgentSession is already active")
+        await self._open_async()
+        self._sync_active = False
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: object | None,
+    ) -> None:
+        """Close the Copilot session and client."""
+        await self._close_async(exc_type, exc, traceback)
+
+    def __enter__(self) -> Self:
+        """Open the Copilot client and session on a background event loop."""
+        if self._active:
+            raise RuntimeError("CopilotAgentSession is already active")
+        self._start_loop_thread()
+        try:
+            self._run_on_loop(self._open_async())
+        except BaseException:
+            self._stop_loop_thread()
+            raise
+        self._sync_active = True
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: object | None,
+    ) -> None:
+        """Close the Copilot session/client and stop the background loop."""
+        try:
+            if self._loop is not None:
+                self._run_on_loop(self._close_async(exc_type, exc, traceback))
+        finally:
+            self._sync_active = False
+            self._stop_loop_thread()
+
+    async def send_and_wait(
+        self,
+        prompt: str,
+        *,
+        timeout: float | None = None,
+    ) -> str:
+        """Send ``prompt`` through the shared session and return assistant text."""
+        if not self._active or self._session is None:
+            raise RuntimeError("CopilotAgentSession is not active")
+        if not isinstance(prompt, str):
+            raise TypeError("prompt must be a str")
+        if timeout is not None and timeout <= 0:
+            raise ValueError("timeout must be greater than 0")
+
+        effective_timeout = self.timeout if timeout is None else timeout
+        if self._send_lock is None:
+            self._send_lock = asyncio.Lock()
+        async with self._send_lock:
+            response = await self._session.send_and_wait(
+                prompt,
+                timeout=effective_timeout,
+            )
+        return self._response_text(response)
+
+    def on(self, handler: Callable[[Any], None]) -> Callable[[], None]:
+        """Subscribe to Copilot session events.
+
+        The returned callable unsubscribes ``handler``. Handlers may be called
+        from the session's event-loop thread when using the synchronous context
+        manager.
+        """
+        if not callable(handler):
+            raise TypeError("handler must be callable")
+        with self._event_lock:
+            self._event_handlers.append(handler)
+
+        def unsubscribe() -> None:
+            with self._event_lock:
+                if handler in self._event_handlers:
+                    self._event_handlers.remove(handler)
+
+        return unsubscribe
+
+    def handler(self) -> TaskHandler:
+        """Return a synchronous AGENT task handler backed by this session."""
+
+        def run(context: TaskContext) -> str:
+            context.raise_if_cancelled()
+            if not self._sync_active or self._loop is None:
+                raise RuntimeError(
+                    "CopilotAgentSession.handler() requires an active sync context",
+                )
+            with self._handler_lock:
+                context.raise_if_cancelled()
+                future = asyncio.run_coroutine_threadsafe(
+                    self.send_and_wait(context.payload, timeout=context.timeout),
+                    self._loop,
+                )
+                while True:
+                    try:
+                        result = future.result(timeout=0.05)
+                    except FutureTimeoutError:
+                        if context.cancelled:
+                            future.cancel()
+                            self._abort_active()
+                            raise TaskCancelled(
+                                f"Task {context.id!r} was cancelled",
+                            ) from None
+                        continue
+                    except FutureCancelledError as error:
+                        raise TaskCancelled(
+                            f"Task {context.id!r} was cancelled",
+                        ) from error
+                    context.raise_if_cancelled()
+                    return result
+
+        return run
+
+    async def _open_async(self) -> None:
+        """Create the SDK client/session pair."""
+        from copilot import CopilotClient
+        from copilot.session import PermissionHandler
+
+        session_options = dict(self._session_options)
+        session_options.setdefault(
+            "on_permission_request",
+            PermissionHandler.approve_all,
+        )
+        session_options["model"] = self.model
+        if self.reasoning_effort is not None:
+            session_options["reasoning_effort"] = self.reasoning_effort
+        if self.working_directory is not None:
+            session_options["working_directory"] = self.working_directory
+        session_options["on_event"] = self._dispatch_event
+
+        client = CopilotClient()
+        entered_client = await client.__aenter__()
+        try:
+            session = await entered_client.create_session(**session_options)
+            entered_session = await session.__aenter__()
+        except BaseException:
+            await entered_client.__aexit__(None, None, None)
+            raise
+
+        self._client = entered_client
+        self._session = entered_session
+        self._send_lock = asyncio.Lock()
+        self._active = True
+
+    async def _close_async(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc: BaseException | None = None,
+        traceback: object | None = None,
+    ) -> None:
+        """Close active SDK resources in reverse creation order."""
+        session = self._session
+        client = self._client
+        self._session = None
+        self._client = None
+        self._send_lock = None
+        self._active = False
+
+        close_error: BaseException | None = None
+        if session is not None:
+            try:
+                await session.__aexit__(exc_type, exc, traceback)
+            except BaseException as error:
+                close_error = error
+        if client is not None:
+            try:
+                await client.__aexit__(exc_type, exc, traceback)
+            except BaseException as error:
+                if close_error is None:
+                    close_error = error
+        if close_error is not None:
+            raise close_error
+
+    async def _abort_active_async(self) -> None:
+        """Abort the active Copilot turn if the SDK session supports it."""
+        session = self._session
+        abort = getattr(session, "abort", None)
+        if callable(abort):
+            await abort()
+
+    def _abort_active(self) -> None:
+        """Best-effort abort for a cancelled synchronous handler call."""
+        if self._loop is None:
+            return
+        future = asyncio.run_coroutine_threadsafe(
+            self._abort_active_async(),
+            self._loop,
+        )
+        future.result(timeout=5)
+
+    @staticmethod
+    def _response_text(response: Any) -> str:
+        """Normalize a Copilot SDK response event to assistant text."""
+        from copilot.generated.session_events import AssistantMessageData
+
+        if response is None or not isinstance(response.data, AssistantMessageData):
+            return ""
+        return response.data.content or ""
+
+    def _dispatch_event(self, event: Any) -> None:
+        """Fan out one SDK event to registered session subscribers."""
+        with self._event_lock:
+            handlers = list(self._event_handlers)
+        for handler in handlers:
+            try:
+                handler(event)
+            except BaseException as error:
+                self.event_errors.append(error)
+
+    def _start_loop_thread(self) -> None:
+        """Start the background event loop used by the sync API."""
+        self._thread_ready.clear()
+
+        def run_loop() -> None:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            self._loop = loop
+            self._thread_ready.set()
+            try:
+                loop.run_forever()
+            finally:
+                loop.close()
+                self._loop = None
+
+        self._thread = Thread(
+            target=run_loop,
+            name="ttasks-copilot-agent-session",
+            daemon=True,
+        )
+        self._thread.start()
+        self._thread_ready.wait()
+
+    def _stop_loop_thread(self) -> None:
+        """Stop and join the background event-loop thread."""
+        loop = self._loop
+        thread = self._thread
+        if loop is not None:
+            loop.call_soon_threadsafe(loop.stop)
+        if thread is not None:
+            thread.join(timeout=5)
+        self._thread = None
+        self._thread_ready.clear()
+
+    def _run_on_loop(self, coroutine: Any) -> Any:
+        """Run ``coroutine`` on the sync background loop and return its result."""
+        if self._loop is None:
+            raise RuntimeError("CopilotAgentSession event loop is not running")
+        future = asyncio.run_coroutine_threadsafe(coroutine, self._loop)
+        return future.result()
+
+
+__all__ = ["CopilotAgentSession"]

ttasks-0.4.0/tests/test_copilot_session.py

@@ -0,0 +1,549 @@
+"""Tests for shared Copilot agent sessions."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+import time
+from concurrent.futures import CancelledError, ThreadPoolExecutor
+from types import ModuleType, SimpleNamespace
+from typing import Any
+
+import pytest
+
+from ttasks import (
+    CopilotAgentSession,
+    Task,
+    TaskCancelled,
+    TaskExecutor,
+    TaskStatus,
+    TaskType,
+)
+
+
+def install_fake_copilot(
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    content: str | None = "response",
+    data: object | None = None,
+    delay: float = 0,
+    enter_error: BaseException | None = None,
+    session_enter_error: BaseException | None = None,
+    session_exit_error: BaseException | None = None,
+    client_exit_error: BaseException | None = None,
+    no_abort: bool = False,
+) -> dict[str, Any]:
+    """Install fake Copilot SDK modules and return recorded calls."""
+    recorded: dict[str, Any] = {
+        "clients": [],
+        "sessions": [],
+        "prompts": [],
+        "timeouts": [],
+        "create_sessions": [],
+        "events": [],
+        "active_sends": 0,
+        "max_active_sends": 0,
+    }
+
+    class AssistantMessageData:
+        """Fake assistant message data."""
+
+        def __init__(self, content: str | None) -> None:
+            self.content = content
+
+    class FakeSession:
+        """Fake Copilot session."""
+
+        def __init__(self, on_event: Any | None) -> None:
+            self.on_event = on_event
+            self.exited = False
+            self.aborted = False
+            recorded["sessions"].append(self)
+
+        async def __aenter__(self) -> FakeSession:
+            if session_enter_error is not None:
+                raise session_enter_error
+            return self
+
+        async def __aexit__(self, *args: object) -> None:
+            self.exited = True
+            recorded["session_exited"] = True
+            if session_exit_error is not None:
+                raise session_exit_error
+
+        async def send_and_wait(
+            self,
+            prompt: str,
+            *,
+            timeout: float | None,
+        ) -> object:
+            recorded["prompts"].append(prompt)
+            recorded["timeouts"].append(timeout)
+            recorded["active_sends"] += 1
+            recorded["max_active_sends"] = max(
+                recorded["max_active_sends"],
+                recorded["active_sends"],
+            )
+            if self.on_event is not None:
+                event = SimpleNamespace(data=AssistantMessageData(f"event:{prompt}"))
+                recorded["events"].append(event)
+                self.on_event(event)
+            try:
+                if delay:
+                    await asyncio.sleep(delay)
+                if data is not None:
+                    return SimpleNamespace(data=data)
+                return SimpleNamespace(data=AssistantMessageData(content))
+            finally:
+                recorded["active_sends"] -= 1
+
+        if not no_abort:
+
+            async def abort(self) -> None:
+                self.aborted = True
+                recorded["aborted"] = True
+
+    class FakeClient:
+        """Fake Copilot client."""
+
+        def __init__(self) -> None:
+            self.exited = False
+            recorded["clients"].append(self)
+
+        async def __aenter__(self) -> FakeClient:
+            if enter_error is not None:
+                raise enter_error
+            recorded["client_entered"] = True
+            return self
+
+        async def __aexit__(self, *args: object) -> None:
+            self.exited = True
+            recorded["client_exited"] = True
+            if client_exit_error is not None:
+                raise client_exit_error
+
+        async def create_session(self, **kwargs: object) -> FakeSession:
+            recorded["create_sessions"].append(kwargs)
+            return FakeSession(kwargs.get("on_event"))
+
+    class FakePermissionHandler:
+        """Fake Copilot permission handler namespace."""
+
+        @staticmethod
+        def approve_all(*args: object) -> object:
+            return object()
+
+    copilot: Any = ModuleType("copilot")
+    copilot.__path__ = []
+    copilot.CopilotClient = FakeClient
+    generated: Any = ModuleType("copilot.generated")
+    generated.__path__ = []
+    session_events: Any = ModuleType("copilot.generated.session_events")
+    session_events.AssistantMessageData = AssistantMessageData
+    session_module: Any = ModuleType("copilot.session")
+    session_module.PermissionHandler = FakePermissionHandler
+
+    monkeypatch.setitem(sys.modules, "copilot", copilot)
+    monkeypatch.setitem(sys.modules, "copilot.generated", generated)
+    monkeypatch.setitem(sys.modules, "copilot.generated.session_events", session_events)
+    monkeypatch.setitem(sys.modules, "copilot.session", session_module)
+    return recorded
+
+
+def test_shared_copilot_agent_session_reuses_one_sdk_session(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Multiple AGENT tasks share one Copilot client/session."""
+    recorded = install_fake_copilot(monkeypatch, content="done")
+    with CopilotAgentSession() as session:
+        executor = TaskExecutor.empty()
+        executor.register(TaskType.AGENT, session.handler())
+
+        first = executor.execute(Task.agent("first", title="First"))
+        second = executor.execute(Task.agent("second", title="Second"))
+
+    assert first.output == "done"
+    assert second.output == "done"
+    assert recorded["prompts"] == ["first", "second"]
+    assert len(recorded["clients"]) == 1
+    assert len(recorded["sessions"]) == 1
+    assert recorded["client_exited"] is True
+    assert recorded["session_exited"] is True
+
+
+def test_shared_copilot_agent_session_rejects_invalid_configuration() -> None:
+    """Session construction rejects invalid model and timeout values."""
+    with pytest.raises(ValueError, match="model must not be empty"):
+        CopilotAgentSession(model="")
+    with pytest.raises(ValueError, match="timeout must be greater than 0"):
+        CopilotAgentSession(timeout=0)
+
+
+def test_shared_copilot_agent_session_passes_session_options(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Session configuration is forwarded to CopilotClient.create_session."""
+    recorded = install_fake_copilot(monkeypatch)
+
+    with CopilotAgentSession(
+        model="agent-custom",
+        reasoning_effort="medium",
+        working_directory="/tmp/repo",
+        streaming=True,
+        excluded_tools=["bash"],
+    ):
+        pass
+
+    create_session = recorded["create_sessions"][0]
+    assert create_session["model"] == "agent-custom"
+    assert create_session["reasoning_effort"] == "medium"
+    assert create_session["working_directory"] == "/tmp/repo"
+    assert create_session["streaming"] is True
+    assert create_session["excluded_tools"] == ["bash"]
+    assert callable(create_session["on_permission_request"])
+    assert callable(create_session["on_event"])
+
+
+def test_shared_copilot_agent_session_handler_uses_task_timeout(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Task timeout overrides the session default timeout for handler calls."""
+    recorded = install_fake_copilot(monkeypatch)
+    with CopilotAgentSession(timeout=30) as session:
+        executor = TaskExecutor.empty()
+        executor.register(TaskType.AGENT, session.handler())
+
+        executor.execute(Task.agent("default timeout", title="Default"))
+        executor.execute(Task.agent("task timeout", title="Task", timeout=2.5))
+
+    assert recorded["timeouts"] == [30, 2.5]
+
+
+def test_shared_copilot_agent_session_handler_uses_no_default_timeout(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """When neither session nor task timeout is set, timeout is forwarded as None."""
+    recorded = install_fake_copilot(monkeypatch)
+    with CopilotAgentSession() as session:
+        executor = TaskExecutor.empty()
+        executor.register(TaskType.AGENT, session.handler())
+
+        executor.execute(Task.agent("no timeout", title="No timeout"))
+
+    assert recorded["timeouts"] == [None]
+
+
+def test_shared_copilot_agent_session_on_subscribes_to_events(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Constructor and explicit event subscribers receive session events."""
+    install_fake_copilot(monkeypatch)
+    seen: list[str] = []
+    explicit: list[str] = []
+
+    def on_event(event: Any) -> None:
+        seen.append(event.data.content)
+
+    with CopilotAgentSession(on_event=on_event) as session:
+        unsubscribe = session.on(lambda event: explicit.append(event.data.content))
+        executor = TaskExecutor.empty()
+        executor.register(TaskType.AGENT, session.handler())
+        executor.execute(Task.agent("hello", title="Hello"))
+        unsubscribe()
+        executor.execute(Task.agent("again", title="Again"))
+
+    assert seen == ["event:hello", "event:again"]
+    assert explicit == ["event:hello"]
+
+
+def test_shared_copilot_agent_session_on_rejects_non_callable() -> None:
+    """Event subscription requires a callable handler."""
+    with pytest.raises(TypeError, match="handler must be callable"):
+        CopilotAgentSession().on("not callable")  # type: ignore[arg-type]
+
+
+def test_shared_copilot_agent_session_event_errors_are_isolated(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """One broken event subscriber does not prevent later subscribers."""
+    install_fake_copilot(monkeypatch)
+    seen: list[str] = []
+
+    def broken(_event: Any) -> None:
+        raise RuntimeError("observer failed")
+
+    with CopilotAgentSession() as session:
+        session.on(broken)
+        session.on(lambda event: seen.append(event.data.content))
+        executor = TaskExecutor.empty()
+        executor.register(TaskType.AGENT, session.handler())
+        executor.execute(Task.agent("hello", title="Hello"))
+
+    assert seen == ["event:hello"]
+    assert len(session.event_errors) == 1
+    assert str(session.event_errors[0]) == "observer failed"
+
+
+def test_shared_copilot_agent_session_rejects_handler_outside_sync_context(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """The synchronous handler fails clearly outside a sync session lifecycle."""
+    install_fake_copilot(monkeypatch)
+    session = CopilotAgentSession()
+    executor = TaskExecutor.empty()
+    executor.register(TaskType.AGENT, session.handler())
+
+    with pytest.raises(RuntimeError, match="requires an active sync context"):
+        executor.execute(Task.agent("hello", title="Hello"))
+
+
+def test_shared_copilot_agent_session_rejects_double_enter(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """An active session cannot be entered again."""
+    install_fake_copilot(monkeypatch)
+    session = CopilotAgentSession()
+    session.__enter__()
+    try:
+        with pytest.raises(RuntimeError, match="already active"):
+            session.__enter__()
+    finally:
+        session.__exit__(None, None, None)
+
+
+def test_shared_copilot_agent_session_rejects_double_async_enter(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """An active async session cannot be entered again."""
+    install_fake_copilot(monkeypatch)
+
+    async def run() -> None:
+        session = CopilotAgentSession()
+        await session.__aenter__()
+        try:
+            with pytest.raises(RuntimeError, match="already active"):
+                await session.__aenter__()
+        finally:
+            await session.__aexit__(None, None, None)
+
+    asyncio.run(run())
+
+
+def test_shared_copilot_agent_session_serializes_concurrent_handler_calls(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """One shared session processes concurrent handler calls one at a time."""
+    recorded = install_fake_copilot(monkeypatch, delay=0.05)
+    with CopilotAgentSession() as session:
+        executor = TaskExecutor.empty()
+        executor.register(TaskType.AGENT, session.handler())
+        tasks = [
+            Task.agent("one", title="One"),
+            Task.agent("two", title="Two"),
+        ]
+
+        with ThreadPoolExecutor(max_workers=2) as pool:
+            results = list(pool.map(executor.execute, tasks))
+
+    assert [result.output for result in results] == ["response", "response"]
+    assert recorded["max_active_sends"] == 1
+    assert sorted(recorded["prompts"]) == ["one", "two"]
+
+
+def test_shared_copilot_agent_session_cancels_in_flight_handler(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Cancelling a running task aborts the active Copilot session turn."""
+    recorded = install_fake_copilot(monkeypatch, delay=1)
+    with CopilotAgentSession() as session:
+        executor = TaskExecutor.empty()
+        executor.register(TaskType.AGENT, session.handler())
+        task = Task.agent("slow", title="Slow")
+        with ThreadPoolExecutor(max_workers=1) as pool:
+            future = pool.submit(executor.execute, task)
+            while recorded["active_sends"] == 0:
+                time.sleep(0.01)
+            executor.cancel(task)
+
+            with pytest.raises(TaskCancelled):
+                future.result(timeout=2)
+
+    assert recorded["aborted"] is True
+    assert task.status is TaskStatus.CANCELLED
+
+
+def test_shared_copilot_agent_session_cancels_without_abort_method(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Cancellation still succeeds if the installed SDK lacks session.abort."""
+    recorded = install_fake_copilot(monkeypatch, delay=1, no_abort=True)
+    with CopilotAgentSession() as session:
+        executor = TaskExecutor.empty()
+        executor.register(TaskType.AGENT, session.handler())
+        task = Task.agent("slow", title="Slow")
+        with ThreadPoolExecutor(max_workers=1) as pool:
+            future = pool.submit(executor.execute, task)
+            while recorded["active_sends"] == 0:
+                time.sleep(0.01)
+            executor.cancel(task)
+
+            with pytest.raises(TaskCancelled):
+                future.result(timeout=2)
+
+    assert "aborted" not in recorded
+    assert task.status is TaskStatus.CANCELLED
+
+
+def test_shared_copilot_agent_session_wraps_cancelled_future(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """A cancelled sync bridge future is surfaced as TaskCancelled."""
+    install_fake_copilot(monkeypatch)
+
+    class FakeFuture:
+        def result(self, *, timeout: float) -> str:
+            raise CancelledError
+
+    def fake_run_coroutine_threadsafe(
+        coroutine: Any,
+        _loop: asyncio.AbstractEventLoop,
+    ) -> FakeFuture:
+        coroutine.close()
+        return FakeFuture()
+
+    original_run_coroutine_threadsafe = asyncio.run_coroutine_threadsafe
+    with CopilotAgentSession() as session:
+        monkeypatch.setattr(
+            asyncio,
+            "run_coroutine_threadsafe",
+            fake_run_coroutine_threadsafe,
+        )
+        executor = TaskExecutor.empty()
+        executor.register(TaskType.AGENT, session.handler())
+        with pytest.raises(TaskCancelled, match="was cancelled"):
+            executor.execute(Task.agent("cancelled", title="Cancelled"))
+        monkeypatch.setattr(
+            asyncio,
+            "run_coroutine_threadsafe",
+            original_run_coroutine_threadsafe,
+        )
+
+
+def test_shared_copilot_agent_session_abort_without_loop_returns() -> None:
+    """Best-effort abort is a no-op before the sync loop is started."""
+    CopilotAgentSession()._abort_active()
+
+
+def test_shared_copilot_agent_session_enter_failure_cleans_up_thread(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Sync enter failures do not leave the background loop thread running."""
+    install_fake_copilot(monkeypatch, enter_error=RuntimeError("connect failed"))
+    session = CopilotAgentSession()
+
+    with pytest.raises(RuntimeError, match="connect failed"), session:
+        pass
+
+    thread = session._thread
+    assert thread is None or not thread.is_alive()
+
+
+def test_shared_copilot_agent_session_session_enter_failure_closes_client(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Session enter failures close the already-entered client."""
+    recorded = install_fake_copilot(
+        monkeypatch,
+        session_enter_error=RuntimeError("session failed"),
+    )
+
+    with pytest.raises(RuntimeError, match="session failed"), CopilotAgentSession():
+        pass
+
+    assert recorded["client_exited"] is True
+
+
+def test_shared_copilot_agent_session_close_raises_session_error(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Session close errors are propagated after close is attempted."""
+    install_fake_copilot(monkeypatch, session_exit_error=RuntimeError("session close"))
+
+    with pytest.raises(RuntimeError, match="session close"), CopilotAgentSession():
+        pass
+
+
+def test_shared_copilot_agent_session_close_raises_client_error(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Client close errors are propagated when session close succeeds."""
+    install_fake_copilot(monkeypatch, client_exit_error=RuntimeError("client close"))
+
+    with pytest.raises(RuntimeError, match="client close"), CopilotAgentSession():
+        pass
+
+
+def test_shared_copilot_agent_session_async_context(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """The async context manager can send directly through the shared session."""
+    recorded = install_fake_copilot(monkeypatch, content="async done")
+
+    async def run() -> str:
+        async with CopilotAgentSession(timeout=7) as session:
+            return await session.send_and_wait("hello")
+
+    output = asyncio.run(run())
+
+    assert output == "async done"
+    assert recorded["prompts"] == ["hello"]
+    assert recorded["timeouts"] == [7]
+
+
+def test_shared_copilot_agent_session_async_validation_and_empty_response(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """The async API validates input and normalizes non-assistant responses."""
+    install_fake_copilot(monkeypatch, content=None)
+
+    async def run() -> None:
+        session = CopilotAgentSession()
+        with pytest.raises(RuntimeError, match="not active"):
+            await session.send_and_wait("inactive")
+        async with session:
+            with pytest.raises(TypeError, match="prompt must be a str"):
+                await session.send_and_wait(123)  # type: ignore[arg-type]
+            with pytest.raises(ValueError, match="timeout must be greater than 0"):
+                await session.send_and_wait("bad timeout", timeout=0)
+            session._send_lock = None
+            assert await session.send_and_wait("empty") == ""
+
+    asyncio.run(run())
+
+
+def test_shared_copilot_agent_session_unknown_response_data_returns_empty(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Unexpected Copilot response data normalizes to an empty string."""
+    install_fake_copilot(monkeypatch, data=object())
+
+    async def run() -> str:
+        async with CopilotAgentSession() as session:
+            return await session.send_and_wait("unknown")
+
+    assert asyncio.run(run()) == ""
+
+
+def test_shared_copilot_agent_session_run_on_loop_requires_loop() -> None:
+    """The sync loop bridge fails clearly if no background loop exists."""
+    session = CopilotAgentSession()
+
+    async def noop() -> None:
+        return None
+
+    coroutine = noop()
+    try:
+        with pytest.raises(RuntimeError, match="event loop is not running"):
+            session._run_on_loop(coroutine)
+    finally:
+        coroutine.close()

{ttasks-0.3.1 → ttasks-0.4.0}/tests/test_e2e.py

@@ -20,6 +20,7 @@ from pathlib import Path
 import pytest
 
 from ttasks import (
+    CopilotAgentSession,
     RetryPolicy,
     SQLiteStore,
     Task,
@@ -549,3 +550,54 @@ def test_mixed_type_copilot_workflow(tmp_path: Path) -> None:
         if task.result is not None:
             assert persisted.result is not None
             assert persisted.result.output == task.result.output
+
+
+@pytest.mark.skipif(
+    not _copilot_available(),
+    reason="Copilot SDK CLI not on PATH; skipping live shared-session test",
+)
+def test_shared_copilot_agent_session_graph_multiturn(tmp_path: Path) -> None:
+    """Two AGENT graph nodes share one Copilot session conversation."""
+    memory_file = tmp_path / "memory.txt"
+    code_word = "blue-sparrow-ttasks-live"
+
+    remember = Task.agent(
+        (
+            "Remember this code word for the next task in this same session: "
+            f"{code_word}. Do not create or modify any files. "
+            f"Reply exactly: remembered {code_word}"
+        ),
+        title="agent_remember",
+        timeout=180,
+    )
+    write_memory = Task.agent(
+        (
+            "Using only the code word I gave you earlier in this session, "
+            "create a file named memory.txt in the working directory containing "
+            "only that code word followed by a newline."
+        ),
+        title="agent_write_memory",
+        timeout=180,
+    )
+    verify_memory = Task.bash(
+        f"test \"$(cat {memory_file})\" = {code_word!r}",
+        title="verify_memory",
+    )
+
+    graph = TaskGraph(title="shared-copilot-session")
+    graph.add(remember)
+    graph.add(write_memory, after=[remember])
+    graph.add(verify_memory, after=[write_memory])
+
+    with CopilotAgentSession(working_directory=str(tmp_path)) as agent:
+        executor = TaskExecutor()
+        executor.register(TaskType.AGENT, agent.handler())
+        graph.run(executor)
+
+    assert graph.ok, (
+        f"graph not ok: statuses="
+        f"{ {task.title: task.status.value for task in graph} }"
+    )
+    for task in graph:
+        assert task.status == TaskStatus.SUCCEEDED
+    assert memory_file.read_text() == f"{code_word}\n"

{ttasks-0.3.1 → ttasks-0.4.0}/tests/test_executor.py

@@ -517,6 +517,22 @@ def test_execute_retry_policy_applies_backoff_between_attempts(
     assert sleeps == [0.25]
 
 
+def test_retry_backoff_long_sleep_returns_at_deadline(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Long retry backoff sleeps in small intervals until the deadline."""
+    task = Task.bash("", title="Example")
+    ticks = iter([0.0, 0.1, 0.6])
+    sleeps: list[float] = []
+
+    monkeypatch.setattr(time, "monotonic", lambda: next(ticks))
+    monkeypatch.setattr(time, "sleep", sleeps.append)
+
+    TaskExecutor._sleep_retry_backoff(task, 0.51)
+
+    assert sleeps == [0.05]
+
+
 def test_execute_retry_policy_honors_cancellation_during_backoff(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:

{ttasks-0.3.1 → ttasks-0.4.0}/tests/test_public_api.py

@@ -15,6 +15,7 @@ from ttasks import _sqlite as sqlite_mod
 from ttasks import _store as store_mod
 from ttasks import _task as task_mod
 from ttasks import _version as version_mod
+from ttasks import copilot as copilot_mod
 
 EXPECTED_PUBLIC_NAMES = {
     "EventBus",
@@ -22,6 +23,7 @@ EXPECTED_PUBLIC_NAMES = {
     "RetryPolicy",
     "SQLiteStore",
     "Store",
+    "CopilotAgentSession",
     "Task",
     "TaskCancelled",
     "TaskContext",
@@ -56,6 +58,7 @@ def test_top_level_names_are_the_same_objects_as_submodule_names() -> None:
     assert ttasks.InMemoryStore is store_mod.InMemoryStore
     assert ttasks.SQLiteStore is sqlite_mod.SQLiteStore
     assert ttasks.Store is store_mod.Store
+    assert ttasks.CopilotAgentSession is copilot_mod.CopilotAgentSession
     assert ttasks.Task is task_mod.Task
     assert ttasks.TaskStatus is task_mod.TaskStatus
     assert ttasks.TaskType is task_mod.TaskType