dreadnode 2.0.14__tar.gz → 2.0.15__tar.gz

{dreadnode-2.0.14 → dreadnode-2.0.15}/PKG-INFO

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

{dreadnode-2.0.14 → dreadnode-2.0.15}/dreadnode/app/api/client.py

@@ -2060,13 +2060,21 @@ class ApiClient:
         message_count: int = 0,
         project_id: str | None = None,
         runtime_id: str | None = None,
+        labels: dict[str, list[str]] | None = None,
+        visibility: t.Literal["private", "workspace"] = "private",
+        origin: t.Literal["user", "eval", "worker"] = "user",
     ) -> dict[str, t.Any]:
         """POST /org/{org}/ws/{workspace}/sessions - Create or save a session."""
         payload: dict[str, t.Any] = {
             "id": session_id,
             "model": model,
             "message_count": message_count,
+            "visibility": visibility,
         }
+        # SES-ORG-003: only send ``origin`` on the wire when non-default —
+        # the platform's ``user`` default applies otherwise.
+        if origin != "user":
+            payload["origin"] = origin
         if agent is not None:
             payload["agent"] = agent
         if title is not None:
@@ -2075,6 +2083,8 @@ class ApiClient:
             payload["project_id"] = project_id
         if runtime_id is not None:
             payload["runtime_id"] = runtime_id
+        if labels is not None:
+            payload["labels"] = labels
         response = self.request("POST", f"/org/{org}/ws/{workspace}/sessions", json_data=payload)
         return t.cast("dict[str, t.Any]", response.json())
 
@@ -2088,8 +2098,15 @@ class ApiClient:
         agent: str | None = None,
         title: str | None = None,
         message_count: int | None = None,
+        labels: dict[str, list[str]] | None = None,
+        visibility: t.Literal["private", "workspace"] | None = None,
     ) -> dict[str, t.Any]:
-        """PATCH /org/{org}/ws/{workspace}/sessions/{session_id} - Update a session."""
+        """PATCH /org/{org}/ws/{workspace}/sessions/{session_id} - Update a session.
+
+        ``labels`` full-replaces non-reserved labels when provided (SES-LBL-042).
+        ``visibility`` may only promote ``private`` → ``workspace``; downgrade
+        returns 403 (SES-ACL-005). Omit fields to leave them unchanged.
+        """
         payload: dict[str, t.Any] = {}
         if model is not None:
             payload["model"] = model
@@ -2099,6 +2116,10 @@ class ApiClient:
             payload["title"] = title
         if message_count is not None:
             payload["message_count"] = message_count
+        if labels is not None:
+            payload["labels"] = labels
+        if visibility is not None:
+            payload["visibility"] = visibility
         response = self.request(
             "PATCH",
             f"/org/{org}/ws/{workspace}/sessions/{session_id}",
@@ -2106,29 +2127,130 @@ class ApiClient:
         )
         return t.cast("dict[str, t.Any]", response.json())
 
+    def archive_session(
+        self,
+        org: str,
+        workspace: str,
+        session_id: str,
+    ) -> dict[str, t.Any]:
+        """POST /org/{org}/ws/{workspace}/sessions/{id}/archive — idempotent."""
+        response = self.request(
+            "POST",
+            f"/org/{org}/ws/{workspace}/sessions/{session_id}/archive",
+        )
+        return t.cast("dict[str, t.Any]", response.json())
+
+    def unarchive_session(
+        self,
+        org: str,
+        workspace: str,
+        session_id: str,
+    ) -> dict[str, t.Any]:
+        """POST /org/{org}/ws/{workspace}/sessions/{id}/unarchive — idempotent."""
+        response = self.request(
+            "POST",
+            f"/org/{org}/ws/{workspace}/sessions/{session_id}/unarchive",
+        )
+        return t.cast("dict[str, t.Any]", response.json())
+
+    def freeze_session(
+        self,
+        org: str,
+        workspace: str,
+        session_id: str,
+    ) -> dict[str, t.Any]:
+        """POST /org/{org}/ws/{workspace}/sessions/{id}/freeze — terminal, idempotent."""
+        response = self.request(
+            "POST",
+            f"/org/{org}/ws/{workspace}/sessions/{session_id}/freeze",
+        )
+        return t.cast("dict[str, t.Any]", response.json())
+
     def list_sessions(
         self,
         org: str,
         workspace: str,
         *,
         page: int = 1,
-        page_size: int = 20,
-        project_id: str | None = None,
+        limit: int = 20,
+        project_id: str | list[str] | None = None,
         user_id: str | None = None,
+        archived: t.Literal["active", "archived", "any"] = "active",
+        label: list[str] | None = None,
+        origin: list[str] | None = None,
+        sort_by: t.Literal[
+            "updated_at", "last_message_at", "created_at", "message_count"
+        ] = "updated_at",
+        sort_dir: t.Literal["asc", "desc"] = "desc",
+        search: str | None = None,
+        include_workload_sessions: bool = False,
     ) -> dict[str, t.Any]:
         """GET /org/{org}/ws/{workspace}/sessions - List sessions.
 
-        The platform endpoint defaults to workspace-wide. Pass ``user_id``
-        to scope to a single creator (e.g. the TUI's "my sessions" view).
+        ``archived`` defaults to ``active`` so archived rows are hidden by
+        default. ``label`` is a repeated ``key:value`` filter (SES-LBL-050).
+        ``project_id`` accepts a single id or a list of ids (repeatable,
+        OR combine — SES-LST-006). ``sort_by`` must be one of
+        ``updated_at`` (default), ``last_message_at``, ``created_at``, or
+        ``message_count``. ``search`` is the full-text filter (SES-LST-007).
         """
-        params: dict[str, t.Any] = {"page": page, "page_size": page_size}
+        params: dict[str, t.Any] = {
+            "page": page,
+            "limit": limit,
+            "archived": archived,
+            "sort_by": sort_by,
+            "sort_dir": sort_dir,
+        }
+        if include_workload_sessions:
+            params["include_workload_sessions"] = True
         if project_id is not None:
             params["project_id"] = project_id
         if user_id is not None:
             params["user_id"] = user_id
+        if label:
+            params["label"] = label
+        if origin:
+            params["origin"] = origin
+        if search:
+            params["search"] = search
         response = self.request("GET", f"/org/{org}/ws/{workspace}/sessions", params=params)
         return t.cast("dict[str, t.Any]", response.json())
 
+    def get_session_facets(
+        self,
+        org: str,
+        workspace: str,
+        *,
+        project_id: str | list[str] | None = None,
+        user_id: str | None = None,
+        archived: t.Literal["active", "archived", "any"] = "active",
+        label: list[str] | None = None,
+        origin: list[str] | None = None,
+        search: str | None = None,
+        include_workload_sessions: bool = False,
+    ) -> dict[str, t.Any]:
+        """GET /org/{org}/ws/{workspace}/sessions/facets - Per-key label value counts.
+
+        Takes the same filter set as :meth:`list_sessions` (minus pagination
+        / sort). ``project_id`` accepts a single id or a list. The response
+        shape is ``{"labels": {key: [{"value": ..., "count": ...}, ...]}}``.
+        """
+        params: dict[str, t.Any] = {"archived": archived}
+        if include_workload_sessions:
+            params["include_workload_sessions"] = True
+        if project_id is not None:
+            params["project_id"] = project_id
+        if user_id is not None:
+            params["user_id"] = user_id
+        if label:
+            params["label"] = label
+        if origin:
+            params["origin"] = origin
+        if search:
+            params["search"] = search
+        response = self.request("GET", f"/org/{org}/ws/{workspace}/sessions/facets", params=params)
+        return t.cast("dict[str, t.Any]", response.json())
+
     def get_session(
         self,
         org: str,

{dreadnode-2.0.14 → dreadnode-2.0.15}/dreadnode/app/api/models.py

@@ -818,6 +818,8 @@ class SessionCreateRequest(BaseModel):
         validation_alias="generateParamsExtra",
     )
     policy: str | dict[str, t.Any] | None = None
+    labels: dict[str, list[str]] | None = None
+    origin: str | None = None
 
     model_config = ConfigDict(populate_by_name=True)
 
@@ -1369,7 +1371,7 @@ class TrainingJobArtifacts(BaseModel):
 # -----------------------------------------------------------------------------
 
 OptimizationBackend = t.Literal["gepa"]
-OptimizationTargetKind = t.Literal["capability_agent"]
+OptimizationTargetKind = t.Literal["capability_agent", "capability_env"]
 OptimizationJobStatus = t.Literal[
     "pending",
     "queued",
@@ -1379,7 +1381,17 @@ OptimizationJobStatus = t.Literal[
     "cancelled",
 ]
 OptimizationLogLevel = t.Literal["debug", "info", "warning", "error"]
-OptimizationComponent = t.Literal["instructions"]
+OptimizationComponent = t.Literal[
+    "instructions",
+    "agent_prompt",
+    "capability_prompt",
+    "skill_descriptions",
+    "skill_bodies",
+]
+_AGENT_COMPONENTS: frozenset[OptimizationComponent] = frozenset({"instructions"})
+_ENV_COMPONENTS: frozenset[OptimizationComponent] = frozenset(
+    {"agent_prompt", "capability_prompt", "skill_descriptions", "skill_bodies"}
+)
 OptimizationProgressEventType = t.Literal[
     "optimization_start",
     "iteration_start",
@@ -1398,6 +1410,12 @@ class OptimizationJobConfig(BaseModel):
 
     model_config = ConfigDict(extra="forbid")
 
+    concurrency: int = 1
+    parallel_rows: int = 1
+    task_ref: str | None = None
+    task_refs: list[str] | None = None
+    val_task_refs: list[str] | None = None
+    timeout_sec: int | None = None
     seed: int = 0
     max_metric_calls: int | None = 100
     max_trials: int | None = None
@@ -1438,22 +1456,83 @@ class CreateOptimizationJobBase(BaseModel):
     run_ref: str | None = None
     capability_ref: CapabilityRef
     agent_name: str | None = None
-    dataset_ref: DatasetRef
+    dataset_ref: DatasetRef | None = None
     val_dataset_ref: DatasetRef | None = None
     reward_recipe: RewardRecipe
-    components: list[OptimizationComponent] = Field(default_factory=lambda: ["instructions"])
+    components: list[OptimizationComponent] | None = None
+    task_ref: str | None = None
+    task_refs: list[str] | None = None
+    val_task_refs: list[str] | None = None
+    timeout_sec: int | None = None
     objective: str | None = None
     config: OptimizationJobConfig = Field(default_factory=OptimizationJobConfig)
     tags: list[str] = Field(default_factory=list)
 
     @model_validator(mode="after")
     def validate_components(self) -> CreateOptimizationJobBase:
+        if self.components is None:
+            self.components = (
+                ["agent_prompt", "capability_prompt", "skill_descriptions", "skill_bodies"]
+                if self.target_kind == "capability_env"
+                else ["instructions"]
+            )
         if not self.components:
             raise ValueError("Hosted optimization jobs require at least one optimizable component")
-        if set(self.components) != {"instructions"}:
-            raise ValueError(
-                "Hosted optimization currently supports only ['instructions'] components"
-            )
+        component_set = set(self.components)
+        if self.target_kind == "capability_agent":
+            invalid = component_set - _AGENT_COMPONENTS
+            if invalid:
+                raise ValueError(
+                    "capability_agent supports only ['instructions'] components"
+                    f" (got {sorted(invalid)})"
+                )
+        else:  # capability_env
+            invalid = component_set - _ENV_COMPONENTS
+            if invalid:
+                raise ValueError(
+                    "capability_env supports component surfaces"
+                    f" {sorted(_ENV_COMPONENTS)} (got {sorted(invalid)})"
+                )
+        return self
+
+    @model_validator(mode="after")
+    def validate_env_requirements(self) -> CreateOptimizationJobBase:
+        if self.target_kind == "capability_env":
+            train_sources = [
+                ("task_refs", bool(self.task_refs)),
+                ("dataset_ref", self.dataset_ref is not None),
+                ("task_ref", self.task_ref is not None),
+            ]
+            active = [name for name, present in train_sources if present]
+            if len(active) == 0:
+                raise ValueError(
+                    "capability_env requires a training surface: provide "
+                    "task_refs, task_ref, or dataset_ref"
+                )
+            if len(active) > 1:
+                raise ValueError(
+                    "capability_env training surface is ambiguous — provide only "
+                    f"one of task_refs / task_ref / dataset_ref (got {active})"
+                )
+            if self.val_task_refs is not None and self.val_dataset_ref is not None:
+                raise ValueError(
+                    "capability_env val surface is ambiguous — provide only one "
+                    "of val_task_refs or val_dataset_ref"
+                )
+        else:
+            if self.task_ref is not None:
+                raise ValueError("task_ref is only valid with target_kind='capability_env'")
+            if self.timeout_sec is not None:
+                raise ValueError("timeout_sec is only valid with target_kind='capability_env'")
+            if self.task_refs is not None:
+                raise ValueError("task_refs is only valid with target_kind='capability_env'")
+            if self.val_task_refs is not None:
+                raise ValueError("val_task_refs is only valid with target_kind='capability_env'")
+            if self.dataset_ref is None:
+                raise ValueError(
+                    "capability_agent requires dataset_ref (dataset rows drive the "
+                    "agent's user message and scoring)"
+                )
         return self
 
 
@@ -1549,8 +1628,10 @@ class OptimizationJob(BaseModel):
     model: str
     project: str | None = None
     run_ref: str | None = None
-    dataset_ref: DatasetRef
+    dataset_ref: DatasetRef | None = None
     val_dataset_ref: DatasetRef | None = None
+    task_refs: list[str] | None = None
+    val_task_refs: list[str] | None = None
     objective: str | None = None
     capability: OptimizationCapabilitySnapshot
     agent_name: str | None = None

{dreadnode-2.0.14 → dreadnode-2.0.15}/dreadnode/app/cli/optimize.py

@@ -34,7 +34,20 @@ OptimizationStatus = t.Literal[
 
 OptimizationBackend = t.Literal["gepa"]
 
-TargetKind = t.Literal["capability_agent"]
+TargetKind = t.Literal["capability_agent", "capability_env"]
+
+EnvComponent = t.Literal[
+    "agent_prompt",
+    "capability_prompt",
+    "skill_descriptions",
+    "skill_bodies",
+]
+_DEFAULT_ENV_COMPONENTS: tuple[EnvComponent, ...] = (
+    "agent_prompt",
+    "capability_prompt",
+    "skill_descriptions",
+    "skill_bodies",
+)
 
 cli = cyclopts.App(name="optimize", help="Optimize agents with jobs.")
 
@@ -83,20 +96,59 @@ def submit(
         str,
         cyclopts.Parameter(help="Capability ref in NAME@VERSION form"),
     ],
-    dataset: t.Annotated[
-        str,
-        cyclopts.Parameter(help="Training dataset ref in NAME@VERSION form"),
-    ],
     reward_recipe: t.Annotated[
         RewardRecipeChoice,
         cyclopts.Parameter(
             help="Hosted reward recipe name",
         ),
     ],
+    dataset: t.Annotated[
+        str | None,
+        cyclopts.Parameter(
+            help=(
+                "Agent-scored dataset ref (NAME@VERSION). Rows drive the agent's "
+                "user message and reward-recipe scoring. Mutually exclusive with "
+                "--task and --task-dataset."
+            ),
+        ),
+    ] = None,
+    task: t.Annotated[
+        list[str] | None,
+        cyclopts.Parameter(
+            negative_iterable=(),
+            help=(
+                "Env-scored training task (repeatable). One value = single task, "
+                "multiple = train-across-tasks. Mutually exclusive with --dataset "
+                "and --task-dataset."
+            ),
+        ),
+    ] = None,
+    task_dataset: t.Annotated[
+        str | None,
+        cyclopts.Parameter(
+            help=(
+                "Env-scored dataset ref (NAME@VERSION) where rows carry task_ref "
+                "plus per-row content (inputs, scoring fields). Use when the "
+                "corpus warrants versioning — otherwise reach for --task. "
+                "Mutually exclusive with --dataset and --task."
+            ),
+        ),
+    ] = None,
     val_dataset: t.Annotated[
         str | None,
         cyclopts.Parameter(
-            help="Optional validation dataset ref in NAME@VERSION form",
+            help="Optional held-out validation dataset (NAME@VERSION).",
+        ),
+    ] = None,
+    val_task: t.Annotated[
+        list[str] | None,
+        cyclopts.Parameter(
+            negative_iterable=(),
+            help=(
+                "Env-scored held-out validation task (repeatable). Never merged "
+                "with training — candidates are mutated against train, scored "
+                "for selection against val."
+            ),
         ),
     ] = None,
     reward_params: t.Annotated[
@@ -180,6 +232,37 @@ def submit(
         float | None, cyclopts.Parameter(help="Timeout in seconds for waiting")
     ] = None,
     as_json: t.Annotated[bool, cyclopts.Parameter(name="--json", negative=())] = False,
+    env_timeout_sec: t.Annotated[
+        int | None,
+        cyclopts.Parameter(
+            help="Per-trial TaskEnvironment timeout in seconds (env-mode only).",
+        ),
+    ] = None,
+    parallel_rows: t.Annotated[
+        int | None,
+        cyclopts.Parameter(
+            validator=cyclopts.validators.Number(gte=1),
+            help="Dataset rows scored concurrently within one candidate (env-mode only; default 1).",
+        ),
+    ] = None,
+    concurrency: t.Annotated[
+        int | None,
+        cyclopts.Parameter(
+            validator=cyclopts.validators.Number(gte=1),
+            help="Candidates evaluated in parallel across the search (default 1).",
+        ),
+    ] = None,
+    component: t.Annotated[
+        list[EnvComponent] | None,
+        cyclopts.Parameter(
+            negative_iterable=(),
+            help=(
+                "Capability surface to optimize (env-mode only, repeatable). "
+                "Defaults to all four: agent_prompt, capability_prompt, "
+                "skill_descriptions, skill_bodies."
+            ),
+        ),
+    ] = None,
     platform: PlatformScopeArgs = PlatformScopeArgs(),
 ) -> None:
     """Submit a hosted optimization job."""
@@ -191,10 +274,56 @@ def submit(
         RewardRecipe,
     )
 
+    # Each training-surface flag is self-identifying. Pick exactly one;
+    # target_kind is inferred from which one the user chose.
+    train_sources = [
+        ("--task", bool(task)),
+        ("--task-dataset", task_dataset is not None),
+        ("--dataset", dataset is not None),
+    ]
+    active_train = [name for name, present in train_sources if present]
+    if len(active_train) == 0:
+        raise ValueError(
+            "submit requires a training surface: --task (env, inline), "
+            "--task-dataset (env, dataset), or --dataset (agent, dataset)"
+        )
+    if len(active_train) > 1:
+        raise ValueError(
+            f"training surface is ambiguous — provide only one of {active_train}. "
+            "--task is env with inline task list; --task-dataset is env with "
+            "curated dataset rows; --dataset is agent-scored."
+        )
+
+    is_env = bool(task) or task_dataset is not None
+    target_kind: TargetKind = "capability_env" if is_env else "capability_agent"
+
+    if val_task and val_dataset:
+        raise ValueError(
+            "val surface is ambiguous — provide only one of --val-task or --val-dataset"
+        )
+    if not is_env:
+        if val_task:
+            raise ValueError("--val-task is only valid in env mode (with --task or --task-dataset)")
+        if env_timeout_sec is not None:
+            raise ValueError("--env-timeout-sec is only valid in env mode")
+        if parallel_rows is not None:
+            raise ValueError("--parallel-rows is only meaningful in env mode")
+        if component:
+            raise ValueError("--component is only valid in env mode")
+
     api, profile = platform.connect()
 
     capability_ref = ArtifactRef.parse_versioned(capability, profile.org_key)
-    dataset_ref = ArtifactRef.parse_versioned(dataset, profile.org_key)
+
+    # Both --dataset and --task-dataset resolve to the same request field
+    # (``dataset_ref``); the distinction is user-facing intent encoded via
+    # the flag choice. The server-side target_kind + validator keep the two
+    # modes unambiguous.
+    dataset_ref_source = dataset or task_dataset
+    dataset_ref: DatasetRef | None = None
+    if dataset_ref_source:
+        dataset_parsed = ArtifactRef.parse_versioned(dataset_ref_source, profile.org_key)
+        dataset_ref = DatasetRef(name=dataset_parsed.name, version=dataset_parsed.version)
 
     val_dataset_ref: DatasetRef | None = None
     if val_dataset:
@@ -236,28 +365,51 @@ def submit(
         config_kwargs["track_best_outputs"] = True
     if display_progress_bar:
         config_kwargs["display_progress_bar"] = True
-
-    request = CreateGEPAOptimizationJobRequest(
-        name=name,
-        model=resolve_model(model),
-        project=profile.project_key,
-        run_ref=run_ref,
-        capability_ref=CapabilityRef(
+    if concurrency is not None:
+        config_kwargs["concurrency"] = concurrency
+    if parallel_rows is not None:
+        config_kwargs["parallel_rows"] = parallel_rows
+
+    if target_kind == "capability_env":
+        components: list[str] = list(component) if component else list(_DEFAULT_ENV_COMPONENTS)
+    else:
+        components = ["instructions"]
+
+    request_kwargs: dict[str, t.Any] = {
+        "name": name,
+        "target_kind": target_kind,
+        "model": resolve_model(model),
+        # Prefer the resolved UUID over the key string. ``validate_scope``
+        # (run by ``platform.connect()``) populates ``project_id`` via a
+        # workspace-scoped lookup, so when it's set the server can resolve
+        # the project unambiguously. Falls back to the key when no project
+        # is configured on the profile.
+        "project": profile.project_id or profile.project_key,
+        "run_ref": run_ref,
+        "capability_ref": CapabilityRef(
             name=capability_ref.name,
             version=capability_ref.version,
         ),
-        agent_name=agent_name,
-        dataset_ref=DatasetRef(name=dataset_ref.name, version=dataset_ref.version),
-        val_dataset_ref=val_dataset_ref,
-        reward_recipe=RewardRecipe(
+        "agent_name": agent_name,
+        "dataset_ref": dataset_ref,
+        "val_dataset_ref": val_dataset_ref,
+        "reward_recipe": RewardRecipe(
             name=reward_recipe,
             params=parsed_reward_params,
         ),
-        components=["instructions"],
-        objective=objective,
-        config=OptimizationJobConfig(**config_kwargs),
-        tags=list(tag or []),
-    )
+        "components": components,
+        "objective": objective,
+        "config": OptimizationJobConfig(**config_kwargs),
+        "tags": list(tag or []),
+    }
+    if task:
+        request_kwargs["task_refs"] = list(task)
+    if val_task:
+        request_kwargs["val_task_refs"] = list(val_task)
+    if env_timeout_sec is not None:
+        request_kwargs["timeout_sec"] = env_timeout_sec
+
+    request = CreateGEPAOptimizationJobRequest(**request_kwargs)
     job = api.create_optimization_job(profile.org_key, profile.workspace_key, request)
     if wait:
         job = _wait_for_optimization_job(

{dreadnode-2.0.14 → dreadnode-2.0.15}/dreadnode/app/client/managed_client.py

@@ -132,6 +132,8 @@ class ManagedRuntimeClient(RuntimeClient):
         project: str | None = None,
         generate_params_extra: dict[str, t.Any] | None = None,
         policy: str | dict[str, t.Any] | None = None,
+        labels: dict[str, list[str]] | None = None,
+        origin: str | None = None,
     ) -> models.SessionInfo:
         """Create a session, defaulting project from the platform profile."""
         resolved_project = project or self._platform_project
@@ -143,6 +145,8 @@ class ManagedRuntimeClient(RuntimeClient):
             project=resolved_project,
             generate_params_extra=generate_params_extra,
             policy=policy,
+            labels=labels,
+            origin=origin,
         )
 
     # ── Server lifecycle ──────────────────────────────────────────