dreadnode 2.0.3__tar.gz → 2.0.5__tar.gz

{dreadnode-2.0.3 → dreadnode-2.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dreadnode
-Version: 2.0.3
+Version: 2.0.5
 Summary: Dreadnode SDK
 Project-URL: Homepage, https://dreadnode.io
 Project-URL: Documentation, https://docs.dreadnode.io
@@ -19,7 +19,7 @@ Requires-Dist: gepa>=0.1.1
 Requires-Dist: httpx<1.0.0,>=0.28.0
 Requires-Dist: jsonpath-ng>=1.7.0
 Requires-Dist: jsonref>=1.1.0
-Requires-Dist: litellm>=1.80.11
+Requires-Dist: litellm<=1.82.2,>=1.80.11
 Requires-Dist: logfire<=3.20.0,>=3.5.3
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: mcp<2.0.0,>=1.25.0

{dreadnode-2.0.3 → dreadnode-2.0.5}/dreadnode/agents/events.py

@@ -4,7 +4,7 @@ from datetime import datetime, timezone
 from uuid import UUID, uuid4
 
 import typing_extensions as te
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, PlainSerializer, WithJsonSchema
 from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
 from rich.panel import Panel
 from rich.rule import Rule
@@ -55,6 +55,14 @@ if t.TYPE_CHECKING:
 AgentEventT = te.TypeVar("AgentEventT", bound="AgentEvent", default="AgentEvent")
 AgentStepT = te.TypeVar("AgentStepT", bound="AgentStep", default="AgentStep")
 AgentStopReason = t.Literal["finished", "max_steps_reached", "error", "stalled"]
+
+# Reusable annotation for error fields that store raw exception objects.
+# Pydantic can't serialize exceptions to JSON, so we coerce to str on serialization.
+# Same pattern as dreadnode.generators.chat.Chat.error.
+_ErrorSerializer = PlainSerializer(lambda x: str(x), return_type=str, when_used="json-unless-none")
+_ErrorJsonSchema = WithJsonSchema({"type": "string", "description": "Error message"})
+SerializableError = t.Annotated[BaseException, _ErrorSerializer, _ErrorJsonSchema]
+SerializableException = t.Annotated[Exception, _ErrorSerializer, _ErrorJsonSchema]
 AgentStatus = t.Literal["running", "stalled", "errored", "finished"]
 
 
@@ -139,7 +147,7 @@ class AgentStep(AgentEvent):
     step: int = 0
     messages: list[Message] = Field(default_factory=list)
     usage: Usage = Usage(input_tokens=0, output_tokens=0, total_tokens=0)
-    error: Exception | None = None
+    error: SerializableException | None = None
     stop: bool | None = None
 
     @property
@@ -231,7 +239,7 @@ class AgentEnd(AgentEvent):
     """
 
     stop_reason: AgentStopReason
-    error: Exception | str | None = None
+    error: SerializableException | str | None = None
 
     def _get_data(self) -> dict[str, t.Any]:
         error = self.error
@@ -336,7 +344,7 @@ class AgentError(AgentEvent):
         error: The error that occurred during the agent's execution.
     """
 
-    error: BaseException
+    error: SerializableError
 
     def _get_data(self) -> dict[str, t.Any]:
         return {
@@ -543,7 +551,7 @@ class ToolError(AgentEvent):
     """
 
     tool_call: ToolCall
-    error: BaseException
+    error: SerializableError
 
     def _get_data(self) -> dict[str, t.Any]:
         return {
@@ -817,7 +825,7 @@ class GenerationError(AgentEvent):
     """
 
     generator: Generator | None = None
-    error: BaseException
+    error: SerializableError
     step: int = 0
     messages: list["Message"] = Field(default_factory=list)
 

{dreadnode-2.0.3 → dreadnode-2.0.5}/dreadnode/app/cli/task.py

@@ -158,6 +158,7 @@ def sync(
     *,
     force: t.Annotated[bool, cyclopts.Parameter(negative=())] = False,
     public: t.Annotated[bool, cyclopts.Parameter(negative=())] = False,
+    workers: t.Annotated[int, cyclopts.Parameter(help="Parallel upload workers.")] = 8,
     registry: RegistryConfig = RegistryConfig(),
 ) -> None:
     """Sync task environments from a directory to the platform."""
@@ -166,7 +167,9 @@ def sync(
         directory,
         force=force,
         public=public,
+        max_workers=workers,
         on_progress=_sync_progress,
+        on_status=lambda msg: print(msg),
     )
 
     total = len(result.uploaded) + len(result.skipped) + len(result.failed)

{dreadnode-2.0.3 → dreadnode-2.0.5}/dreadnode/app/main.py

@@ -1819,13 +1819,37 @@ class Dreadnode:
         result.blobs_skipped += oci_result.blobs_existed
         return result
 
+    def _fetch_remote_task_digests(self, org: str) -> dict[str, str]:
+        """Fetch all remote task OCI digests in bulk via paginated list.
+
+        Returns a mapping of ``{task_name: oci_layer_sha}`` for every task
+        that has a recorded OCI digest.
+        """
+        digests: dict[str, str] = {}
+        page = 1
+        while True:
+            resp = self.api.list_tasks(org, page=page, limit=100)
+            for item in resp.get("tasks", []):
+                name = item.get("name")
+                raw = item.get("oci_digest")
+                if name and isinstance(raw, str) and raw:
+                    sha = raw.split(":", 1)[-1] if ":" in raw else raw
+                    digests[name] = sha
+            total = resp.get("total", 0)
+            if page * 100 >= total:
+                break
+            page += 1
+        return digests
+
     def sync_environments(
         self,
         directory: str | Path,
         *,
         force: bool = False,
         public: bool = False,
+        max_workers: int = 8,
         on_progress: t.Callable[[str, str, str | None], None] | None = None,
+        on_status: t.Callable[[str], None] | None = None,
     ) -> EnvironmentSyncResult:
         """Sync task environments from a directory to the platform.
 
@@ -1837,11 +1861,15 @@ class Dreadnode:
             directory: Root directory containing task subdirectories.
             force: Upload even when the remote SHA matches.
             public: Set ``is_public=True`` after upload.
+            max_workers: Maximum parallel build/upload threads.
             on_progress: Optional callback ``(name, status, error)`` for each task.
 
         Returns:
             :class:`EnvironmentSyncResult` with uploaded/skipped/failed details.
         """
+        import concurrent.futures
+        import threading
+
         from dreadnode.packaging.oci import build_environment
 
         if not self.can_sync:
@@ -1851,13 +1879,18 @@ class Dreadnode:
 
         from dreadnode.packaging.task_validation import discover_task_directories
 
+        _status = on_status or (lambda _msg: None)
+
         root = Path(directory).resolve()
         if not root.is_dir():
             raise FileNotFoundError(f"Task directory not found: {root}")
 
         org = self.session.org_key
 
+        _status("Discovering tasks...")
         task_dirs, conflicts = discover_task_directories(root)
+        _status(f"Found {len(task_dirs)} task(s)")
+
         if conflicts and on_progress:
             for parent, nested in conflicts:
                 on_progress(
@@ -1869,9 +1902,17 @@ class Dreadnode:
         result = EnvironmentSyncResult(
             failed=[(nested.name, f"nested inside {parent.name}") for parent, nested in conflicts],
         )
-        oci_client = self.storage.oci_client()
 
-        for task_dir in task_dirs:
+        # Batch-fetch all remote digests (one paginated call vs N individual GETs)
+        _status("Fetching remote digests...")
+        remote_digests = self._fetch_remote_task_digests(org) if not force else {}
+        _status(
+            f"Fetched {len(remote_digests)} remote digest(s), syncing with {max_workers} workers..."
+        )
+
+        lock = threading.Lock()
+
+        def _sync_one(task_dir: Path) -> None:
             dir_name = task_dir.name
             try:
                 env_name, env_version = _load_environment_metadata(task_dir)
@@ -1883,33 +1924,44 @@ class Dreadnode:
                     raise ValueError("Environment OCI image has no layers")  # noqa: TRY301
                 local_sha = image.layers[0].digest.split(":", 1)[-1]
 
-                remote_sha = self._get_remote_task_sha(org, env_name)
+                remote_sha = remote_digests.get(env_name)
                 if not force and remote_sha and remote_sha == local_sha:
-                    result.skipped.append(env_name)
+                    if public:
+                        self.api.update_task_visibility(org, env_name, is_public=True)
+                    with lock:
+                        result.skipped.append(env_name)
                     if on_progress:
                         on_progress(env_name, "skipped", None)
-                    continue
+                    return
 
+                # Each thread gets its own OCI client (own httpx.Client)
+                oci_client = self.storage.oci_client()
                 push_result = oci_client.push(resolved_name, env_version, image)
                 if not push_result.success:
                     msg = "; ".join(push_result.errors) or "OCI push failed"
-                    result.failed.append((env_name, msg))
+                    with lock:
+                        result.failed.append((env_name, msg))
                     if on_progress:
                         on_progress(env_name, "failed", msg)
-                    continue
+                    return
 
                 if public:
                     self.api.update_task_visibility(org, env_name, is_public=True)
 
-                result.uploaded.append(env_name)
+                with lock:
+                    result.uploaded.append(env_name)
                 if on_progress:
                     on_progress(env_name, "uploaded", None)
 
             except Exception as exc:
-                result.failed.append((dir_name, str(exc)))
+                with lock:
+                    result.failed.append((dir_name, str(exc)))
                 if on_progress:
                     on_progress(dir_name, "failed", str(exc))
 
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as pool:
+            list(pool.map(_sync_one, task_dirs))
+
         return result
 
     def pull_package(

{dreadnode-2.0.3 → dreadnode-2.0.5}/dreadnode/app/server/app.py

@@ -60,7 +60,7 @@ if t.TYPE_CHECKING:
     from dreadnode.storage import SessionRecord, SessionStore
 
 EventPayload = dict[str, t.Any]
-_TERMINAL_CHAT_EVENT_TYPES = frozenset({"agentend", "error"})
+_TERMINAL_CHAT_EVENT_TYPES = frozenset({"agentend", "error", "cancelled"})
 DEFAULT_MODEL = "anthropic/claude-sonnet-4-20250514"
 _DREADNODE_LLM_BASE_ENV = "DREADNODE_LLM_BASE"
 _DREADNODE_LLM_API_KEY_ENV = "DREADNODE_LLM_API_KEY"
@@ -812,6 +812,7 @@ def create_agent(
         instructions=instructions,
         tools=tools,
         hooks=hooks,
+        max_steps=500,
     )
 
 
@@ -1826,6 +1827,28 @@ class SessionRuntime:
         if self._processing_task is not None and not self._processing_task.done():
             self._processing_task.cancel()
 
+    async def cancel(self) -> bool:
+        """Cancel the active turn and drain queued requests.
+
+        Returns True if a running turn was cancelled, False if already idle.
+        """
+        was_busy = False
+        if self._processing_task is not None and not self._processing_task.done():
+            self._processing_task.cancel()
+            was_busy = True
+            # Wait for the task to finish its cancellation cleanup
+            with suppress(asyncio.CancelledError):
+                await self._processing_task
+
+        # Drain any queued requests so their SSE connections terminate
+        async with self._queue_lock:
+            while self._queue:
+                queued = self._queue.popleft()
+                await queued.event_queue.put(None)
+            self._processing_task = None
+
+        return was_busy
+
     def persist_manifest(self) -> None:
         """Persist minimal runtime metadata needed to rebind the session."""
         self._ensure_session_dir()
@@ -1905,6 +1928,7 @@ class SessionRuntime:
             )
             _log_chat_timing(self.session_id, "processor_start", request.queued_at_monotonic)
 
+            cancelled = False
             try:
                 if request.model is not None and request.model != self.model:
                     self.model = request.model
@@ -2004,13 +2028,25 @@ class SessionRuntime:
                 # Clear cached agent so restore paths create fresh
                 self._agent = None
                 self._persist_state()
+            except asyncio.CancelledError:
+                cancelled = True
+                logger.info("Session {}: turn cancelled by user", self.session_id[:8])
+                # Persist whatever trajectory we have so far
+                self._agent = None
+                self._persist_state()
+                await request.event_queue.put(
+                    {"type": "cancelled", "data": {"reason": "user_interrupt"}}
+                )
+                # Don't re-raise — let the method exit cleanly so cancel() can drain remaining queue
+                return
             except Exception as exc:
                 logger.exception("Error during chat for session {}", self.session_id)
                 await request.event_queue.put({"type": "error", "error": str(exc)})
             finally:
                 logger.debug("Session {}: chat turn complete", self.session_id[:8])
                 _log_chat_timing(self.session_id, "processor_complete", request.queued_at_monotonic)
-                await request.event_queue.put(None)
+                if not cancelled:
+                    await request.event_queue.put(None)
 
     def _first_user_preview(self, max_len: int = 200) -> str | None:
         """Extract preview text from the first user message in the trajectory."""
@@ -2228,6 +2264,21 @@ async def reset_session(session_id: str) -> JSONResponse:
     return JSONResponse(content={"status": "reset", "session_id": session_id})
 
 
+@app.post("/api/sessions/{session_id}/cancel")
+async def cancel_session(session_id: str) -> JSONResponse:
+    """Cancel the active turn and drain queued requests for a session."""
+    session = get_state().get_session(session_id)
+    if session is None:
+        raise HTTPException(status_code=404, detail=f"Session not found: {session_id}")
+    was_busy = await session.cancel()
+    return JSONResponse(
+        content={
+            "status": "cancelled" if was_busy else "idle",
+            "session_id": session_id,
+        }
+    )
+
+
 @app.post("/api/sessions/{session_id}/compact")
 async def compact_session(session_id: str, body: dict[str, t.Any] | None = None) -> JSONResponse:
     """Compact a session's conversation history (CMP-API-001)."""