dreadnode 2.0.16__tar.gz → 2.0.17__tar.gz

{dreadnode-2.0.16 → dreadnode-2.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dreadnode
-Version: 2.0.16
+Version: 2.0.17
 Summary: Dreadnode SDK
 Project-URL: Homepage, https://dreadnode.io
 Project-URL: Documentation, https://docs.dreadnode.io

{dreadnode-2.0.16 → dreadnode-2.0.17}/dreadnode/app/api/client.py

@@ -318,6 +318,15 @@ class ApiClient:
         response = self.request("GET", "/inference/catalog", params=params)
         return t.cast("list[dict[str, t.Any]]", response.json().get("models", []))
 
+    def validate_inference_model(self, model_id: str) -> dict[str, t.Any]:
+        """POST /api/v1/inference/validate - Validate a model ID via LiteLLM."""
+        response = self.request(
+            "POST",
+            "/inference/validate",
+            json_data={"model_id": model_id},
+        )
+        return t.cast("dict[str, t.Any]", response.json())
+
     def get_user_preferences(self) -> dict[str, t.Any]:
         """GET /api/v1/user/preferences - Get user's enabled models with status."""
         response = self.request("GET", "/user/preferences")
@@ -2229,6 +2238,33 @@ class ApiClient:
         )
         return t.cast("dict[str, t.Any]", response.json())
 
+    def delete_session(
+        self,
+        org: str,
+        workspace: str,
+        session_id: str,
+    ) -> bool:
+        """DELETE /org/{org}/ws/{workspace}/sessions/{id}.
+
+        Returns ``True`` when the platform deleted the row, ``False`` when
+        the session was already absent (404). Other failures raise — a
+        local-only session that was never registered with the platform
+        still 404s here, so the caller can safely treat that as success.
+        """
+        response = self._request(
+            "DELETE",
+            f"/org/{org}/ws/{workspace}/sessions/{session_id}",
+        )
+        if response.status_code == 404:
+            return False
+        if response.status_code == 401:
+            raise AuthenticationError(self._get_error_message(response))
+        try:
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            raise RuntimeError(self._get_error_message(response)) from e
+        return True
+
     def unarchive_session(
         self,
         org: str,

{dreadnode-2.0.16 → dreadnode-2.0.17}/dreadnode/app/api/models.py

@@ -806,28 +806,59 @@ class HumanPromptOption(BaseModel):
     description: str | None = None
 
 
+class HumanQuestion(BaseModel):
+    """A single question inside a ``HumanPrompt`` bundle."""
+
+    kind: t.Literal["choice", "input"]
+    prompt: str
+    header: str | None = None
+    options: list[HumanPromptOption] = Field(default_factory=list)
+    multiple: bool = False
+    custom: bool = True
+
+    @model_validator(mode="after")
+    def _validate_choice_options(self) -> HumanQuestion:
+        if self.kind == "choice" and not self.options:
+            raise ValueError("choice questions require at least one option")
+        return self
+
+
 class HumanPrompt(BaseModel):
-    """Prompt sent to a human for input, choice, or approval."""
+    """Bundle of one or more questions sent to a human via ``ask_user``."""
 
     request_id: str
-    kind: t.Literal["input", "choice", "approval"]
-    question: str
-    details: str | None = None
-    options: list[HumanPromptOption] | None = None
-    allow_free_text: bool | None = None
-    default_option: str | None = None
-    severity: str | None = None
-    source_tool_name: str | None = None
-    source_tool_call_id: str | None = None
+    questions: list[HumanQuestion]
+
+    @model_validator(mode="after")
+    def _validate_questions(self) -> HumanPrompt:
+        if not self.questions:
+            raise ValueError("HumanPrompt requires at least one question")
+        return self
+
+
+class QuestionAnswer(BaseModel):
+    """Answer to a single ``HumanQuestion``."""
+
+    selected_labels: list[str] = Field(default_factory=list)
+    custom_text: str | None = None
+    text: str | None = None
+    was_custom: bool = False
 
 
 class HumanInputResponse(BaseModel):
-    """Structured response from a human prompt."""
+    """Structured response from a ``HumanPrompt``."""
 
     request_id: str
-    action: t.Literal["submit", "cancel", "approve", "deny", "allow_session"]
-    text: str | None = None
-    selected_option: str | None = None
+    action: t.Literal["submit", "cancel"]
+    answers: list[QuestionAnswer] | None = None
+
+    @model_validator(mode="after")
+    def _validate_action_answers(self) -> HumanInputResponse:
+        if self.action == "submit" and self.answers is None:
+            raise ValueError("submit responses require answers")
+        if self.action == "cancel" and self.answers:
+            raise ValueError("cancel responses must not carry answers")
+        return self
 
 
 class ChatRequest(BaseModel):