mainsequence 4.4.11__tar.gz → 4.4.12__tar.gz

{mainsequence-4.4.11/mainsequence.egg-info → mainsequence-4.4.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 4.4.11
+Version: 4.4.12
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License: MainSequence GmbH SDK License Agreement

{mainsequence-4.4.11 → mainsequence-4.4.12}/mainsequence/cli/api.py

@@ -1239,6 +1239,60 @@ def get_agent_latest_session(
         raise ApiError(f"Agent latest session fetch failed: {e}") from e
 
 
+def list_agent_sessions(
+    *,
+    timeout: int | None = None,
+    filters: dict[str, Any] | None = None,
+    agent_uid: str | None = None,
+    agent_unique_id: str | None = None,
+) -> list[dict[str, Any]]:
+    """
+    List agent sessions via SDK client model, optionally scoped to one agent.
+    """
+    if agent_uid and agent_unique_id:
+        raise ApiError("Pass either agent_uid or agent_unique_id, not both.")
+
+    session_filters = dict(filters or {})
+    if agent_uid:
+        session_filters["agent_uid"] = str(agent_uid)
+    elif agent_unique_id:
+        try:
+            agent = _run_sdk_model_operation(
+                module_name="mainsequence.client.agent_runtime_models",
+                class_name="Agent",
+                operation=lambda ClientAgent: ClientAgent.get_by_agent_unique_id(
+                    str(agent_unique_id), timeout=timeout
+                ),
+            )
+        except Exception as e:
+            err_name = type(e).__name__
+            if err_name in {"DoesNotExist", "NotFoundError"}:
+                raise ApiError(f"Agent not found for agent_unique_id={agent_unique_id!r}") from e
+            if isinstance(e, (ApiError, NotLoggedIn)):
+                raise
+            raise ApiError(f"Agent lookup failed for agent_unique_id={agent_unique_id!r}: {e}") from e
+
+        resolved_agent = _sdk_object_to_dict(agent)
+        resolved_agent_uid = str(resolved_agent.get("uid") or "").strip()
+        if not resolved_agent_uid:
+            raise ApiError(f"Agent lookup returned no uid for agent_unique_id={agent_unique_id!r}")
+        session_filters["agent_uid"] = resolved_agent_uid
+
+    try:
+        payload = _run_sdk_model_operation(
+            module_name="mainsequence.client.agent_runtime_models",
+            class_name="AgentSession",
+            operation=lambda ClientAgentSession: ClientAgentSession.filter(
+                timeout=timeout, **session_filters
+            ),
+        )
+        return [_sdk_object_to_dict(item) for item in list(payload or [])]
+    except Exception as e:
+        if isinstance(e, (ApiError, NotLoggedIn)):
+            raise
+        raise ApiError(f"Agent sessions fetch failed: {e}") from e
+
+
 def get_agent_session(
     agent_session_uid: str,
     *,

{mainsequence-4.4.11 → mainsequence-4.4.12}/mainsequence/cli/cli.py

@@ -130,6 +130,7 @@ from .api import (
     get_secret,
     get_workspace,
     list_agent_runs,
+    list_agent_sessions,
     list_agent_users_can_edit,
     list_agent_users_can_view,
     list_agents,
@@ -3948,6 +3949,82 @@ def _agent_get_latest_session_impl(
     print_kv("Agent Session Details", _format_agent_session_details(agent_session_payload))
 
 
+def _agent_session_list_impl(
+    *,
+    agent_uid: str | None,
+    agent_unique_id: str | None,
+    timeout: int | None,
+    filter_entries: list[str] | None,
+    show_filters: bool,
+) -> None:
+    filters = _resolve_cli_list_filters(
+        model_ref=AGENT_SESSION_MODEL_REF,
+        filter_entries=filter_entries,
+        show_filters=show_filters,
+        command_label="Agent Sessions",
+    )
+    if agent_uid and agent_unique_id:
+        error("Pass either `--agent-uid` or `--agent-unique-id`, not both.")
+        raise typer.Exit(1)
+    if (agent_uid or agent_unique_id) and any(
+        key in filters for key in ("agent_uid", "agent_uid__in")
+    ):
+        error(
+            "Do not pass `--filter agent_uid=...` with `--agent-uid` or "
+            "`--agent-unique-id`. Use only one agent scope."
+        )
+        raise typer.Exit(1)
+
+    _require_login()
+
+    try:
+        agent_sessions = list_agent_sessions(
+            timeout=timeout,
+            filters=filters,
+            agent_uid=agent_uid,
+            agent_unique_id=agent_unique_id,
+        )
+    except ApiError as e:
+        error(f"Agent sessions fetch failed: {e}")
+        raise typer.Exit(1) from e
+
+    if _emit_json(agent_sessions):
+        return
+
+    rows: list[list[str]] = []
+    for agent_session_payload in agent_sessions:
+        rows.append(
+            [
+                str(agent_session_payload.get("uid") or "-"),
+                str(agent_session_payload.get("agent_uid") or "-"),
+                str(
+                    agent_session_payload.get("agent_name")
+                    or agent_session_payload.get("agent_type")
+                    or "-"
+                ),
+                str(agent_session_payload.get("status") or "-"),
+                str(
+                    agent_session_payload.get("runtime_state")
+                    or agent_session_payload.get("engine_name")
+                    or "-"
+                ),
+                str(agent_session_payload.get("started_at") or "-"),
+                str(agent_session_payload.get("ended_at") or "-"),
+                str(agent_session_payload.get("name") or "-"),
+            ]
+        )
+
+    if rows:
+        print_table(
+            "Agent Sessions",
+            ["UID", "Agent UID", "Agent", "Status", "Runtime", "Started At", "Ended At", "Name"],
+            rows,
+        )
+    else:
+        info("No agent sessions.")
+    info(f"Total agent sessions: {len(agent_sessions)}")
+
+
 def _agent_session_detail_impl(
     *,
     agent_session_uid: str,
@@ -6674,6 +6751,51 @@ def agent_get_latest_session_cmd(
     _agent_get_latest_session_impl(agent_uid=agent_uid, timeout=timeout)
 
 
+@agent_session_group.command("list")
+def agent_session_list_cmd(
+    agent_uid: str | None = pydantic_option(
+        AGENT_SESSION_MODEL_REF,
+        "agent_uid",
+        None,
+        "--agent-uid",
+        help="Agent UID to scope the session list.",
+    ),
+    agent_unique_id: str | None = pydantic_option(
+        AGENT_MODEL_REF,
+        "agent_unique_id",
+        None,
+        "--agent-unique-id",
+        help="Agent unique id to resolve before listing sessions.",
+    ),
+    filter_entries: list[str] | None = typer.Option(None, "--filter", help=LIST_FILTER_OPTION_HELP),
+    show_filters: bool = typer.Option(
+        False, "--show-filters", help="Show the filters supported by this list command and exit."
+    ),
+    timeout: int | None = typer.Option(None, "--timeout", help="Request timeout in seconds"),
+):
+    """
+    List agent sessions, optionally scoped to one agent.
+
+    Uses SDK client `AgentSession.filter()` as the single source of truth.
+
+    Examples
+    --------
+    ```bash
+    mainsequence agent session list
+    mainsequence agent session list --agent-uid e0e75693-4110-464c-93e0-82c7fd9c9a23
+    mainsequence agent session list --agent-unique-id research-copilot
+    mainsequence agent session list --agent-uid e0e75693-4110-464c-93e0-82c7fd9c9a23 --filter status=running
+    ```
+    """
+    _agent_session_list_impl(
+        agent_uid=agent_uid,
+        agent_unique_id=agent_unique_id,
+        timeout=timeout,
+        filter_entries=filter_entries,
+        show_filters=show_filters,
+    )
+
+
 @agent_session_group.command("detail")
 def agent_session_detail_cmd(
     agent_session_uid: str = pydantic_argument(

{mainsequence-4.4.11 → mainsequence-4.4.12}/mainsequence/client/agent_runtime_models.py

@@ -48,6 +48,54 @@ class AgentSemanticSearchResult(BasePydanticModel):
     )
 
 
+class AgentRuntimeImageDriftCheck(BasePydanticModel):
+    key: str = Field(..., description="Machine-readable identifier for the drift check.")
+    label: str = Field(..., description="Human-readable label for the drift check.")
+    status: str = Field(..., description="Backend status for this drift check.")
+    has_drift: bool = Field(..., description="Whether this check detected runtime drift.")
+    matches: bool = Field(..., description="Whether the actual runtime state matches the expected state.")
+    reason: str = Field("", description="Machine-readable explanation for the status.")
+    message: str = Field("", description="Human-readable explanation for this drift check.")
+    autoheal_supported: bool = Field(
+        False,
+        description="Whether the backend can automatically repair this specific drift condition.",
+    )
+    autoheal_mode: str | None = Field(
+        None,
+        description="Backend repair mode for this check when automatic repair is supported.",
+    )
+    autoheal_message: str | None = Field(
+        None,
+        description="Human-readable automatic repair guidance for this check.",
+    )
+    expected_image_uri: str = Field("", description="Expected runtime image URI, when the check is image-based.")
+    actual_image_uri: str = Field("", description="Actual runtime image URI, when the check is image-based.")
+    expected_commit_hash: str = Field("", description="Expected project commit hash, when the check is commit-based.")
+    actual_commit_hash: str = Field("", description="Actual runtime commit hash, when the check is commit-based.")
+
+
+class AgentRuntimeImageDrift(BasePydanticModel):
+    agent_kind: str = Field(..., description="Runtime family that produced the drift payload.")
+    available: bool = Field(..., description="Whether drift information could be resolved.")
+    has_drift: bool = Field(..., description="Whether any included drift check is currently drifting.")
+    autoheal_available: bool = Field(
+        False,
+        description="Whether all currently drifting checks can be repaired automatically by the backend.",
+    )
+    autoheal_message: str | None = Field(
+        None,
+        description="Human-readable summary of automatic repair availability.",
+    )
+    checks: list[AgentRuntimeImageDriftCheck] = Field(
+        default_factory=list,
+        description="Individual runtime drift checks returned by the backend.",
+    )
+    detail: str | None = Field(
+        None,
+        description="Additional backend detail when drift information is unavailable or degraded.",
+    )
+
+
 class AgentSessionRuntimeAccess(BasePydanticModel):
     coding_agent_service_id: str = Field(
         ...,
@@ -69,6 +117,24 @@ class AgentSessionRuntimeAccess(BasePydanticModel):
         ...,
         description="Bearer token that authorizes calls to the coding-agent gateway.",
     )
+    is_ready: bool = Field(
+        False,
+        description="Whether the resolved coding-agent runtime is currently routable.",
+    )
+    knative_service_runtime_uid: str | None = Field(
+        None,
+        description="Public UID of the linked Knative service runtime, when the backend has one.",
+    )
+    image_drift: AgentRuntimeImageDrift | None = Field(
+        None,
+        description="Runtime image drift payload for the resolved coding-agent runtime.",
+    )
+
+    @property
+    def image_drift_dict(self) -> dict[str, Any] | None:
+        if self.image_drift is None:
+            return None
+        return self.image_drift.model_dump()
 
 
 class Agent(ShareableObjectMixin, BaseObjectOrm, BasePydanticModel):
@@ -445,6 +511,7 @@ class AgentSession(BaseObjectOrm, BasePydanticModel):
     ENDPOINT: ClassVar[str] = "agents/v1/sessions"
     FILTERSET_FIELDS: ClassVar[dict[str, list[str]] | None] = {
         "uid": ["exact", "in"],
+        "agent_uid": ["exact", "in"],
         "status": ["exact"],
         "search": ["exact"],
         "q": ["exact"],
@@ -452,6 +519,8 @@ class AgentSession(BaseObjectOrm, BasePydanticModel):
     FILTER_VALUE_NORMALIZERS: ClassVar[dict[str, str]] = {
         "uid": "uid",
         "uid__in": "uid",
+        "agent_uid": "uid",
+        "agent_uid__in": "uid",
         "status": "str",
         "search": "str",
         "q": "str",
@@ -597,6 +666,8 @@ class AgentSession(BaseObjectOrm, BasePydanticModel):
 
 __all__ = [
     "Agent",
+    "AgentRuntimeImageDrift",
+    "AgentRuntimeImageDriftCheck",
     "AgentSemanticSearchResult",
     "AgentSessionRuntimeAccess",
     "UserOrchestratorAgentService",

{mainsequence-4.4.11 → mainsequence-4.4.12/mainsequence.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 4.4.11
+Version: 4.4.12
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License: MainSequence GmbH SDK License Agreement

{mainsequence-4.4.11 → mainsequence-4.4.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence"
-version = "4.4.11"
+version = "4.4.12"
 description = "Main Sequence SDK "
 readme = "README.md"
 requires-python = ">=3.11"

{mainsequence-4.4.11 → mainsequence-4.4.12}/tests/test_cli.py

@@ -1848,6 +1848,107 @@ def test_get_agent_latest_session_uses_client_model(cli_mod, monkeypatch):
     assert out["uid"] == session_uid
 
 
+def test_list_agent_sessions_uses_client_model(cli_mod, monkeypatch):
+    api_mod = importlib.import_module("mainsequence.cli.api")
+    captured = {}
+    agent_uid = "e0e75693-4110-464c-93e0-82c7fd9c9a23"
+    session_uid = "3f1cc452-43ec-49cb-b2ba-87dbac164d29"
+
+    class FakeAgentSession:
+        @staticmethod
+        def model_dump(mode="json"):
+            return {
+                "uid": session_uid,
+                "agent_uid": agent_uid,
+                "status": "completed",
+                "llm_provider": "openai",
+                "llm_model": "gpt-5.4",
+                "engine_name": "codex",
+            }
+
+    def _run_sdk_model_operation(*, module_name, class_name, operation, project_id_env=None):
+        captured["module_name"] = module_name
+        captured["class_name"] = class_name
+
+        class _ClientAgentSession:
+            @classmethod
+            def filter(cls, timeout=None, **filters):
+                captured["timeout"] = timeout
+                captured["filters"] = filters
+                return [FakeAgentSession()]
+
+        return operation(_ClientAgentSession)
+
+    monkeypatch.setattr(api_mod, "_run_sdk_model_operation", _run_sdk_model_operation)
+
+    out = api_mod.list_agent_sessions(
+        timeout=18,
+        filters={"status": "completed"},
+        agent_uid=agent_uid,
+    )
+    assert captured == {
+        "module_name": "mainsequence.client.agent_runtime_models",
+        "class_name": "AgentSession",
+        "timeout": 18,
+        "filters": {"status": "completed", "agent_uid": agent_uid},
+    }
+    assert out == [FakeAgentSession().model_dump()]
+
+
+def test_list_agent_sessions_resolves_agent_unique_id(cli_mod, monkeypatch):
+    api_mod = importlib.import_module("mainsequence.cli.api")
+    captured = {"calls": []}
+    agent_uid = "e0e75693-4110-464c-93e0-82c7fd9c9a23"
+    session_uid = "3f1cc452-43ec-49cb-b2ba-87dbac164d29"
+
+    class FakeAgent:
+        @staticmethod
+        def model_dump(mode="json"):
+            return {"uid": agent_uid, "agent_unique_id": "research-copilot"}
+
+    class FakeAgentSession:
+        @staticmethod
+        def model_dump(mode="json"):
+            return {"uid": session_uid, "agent_uid": agent_uid, "status": "running"}
+
+    def _run_sdk_model_operation(*, module_name, class_name, operation, project_id_env=None):
+        captured["calls"].append((module_name, class_name))
+        if class_name == "Agent":
+
+            class _ClientAgent:
+                @classmethod
+                def get_by_agent_unique_id(cls, agent_unique_id, timeout=None):
+                    captured["agent_unique_id"] = agent_unique_id
+                    captured["agent_timeout"] = timeout
+                    return FakeAgent()
+
+            return operation(_ClientAgent)
+
+        class _ClientAgentSession:
+            @classmethod
+            def filter(cls, timeout=None, **filters):
+                captured["session_timeout"] = timeout
+                captured["filters"] = filters
+                return [FakeAgentSession()]
+
+        return operation(_ClientAgentSession)
+
+    monkeypatch.setattr(api_mod, "_run_sdk_model_operation", _run_sdk_model_operation)
+
+    out = api_mod.list_agent_sessions(agent_unique_id="research-copilot", timeout=19)
+    assert captured == {
+        "calls": [
+            ("mainsequence.client.agent_runtime_models", "Agent"),
+            ("mainsequence.client.agent_runtime_models", "AgentSession"),
+        ],
+        "agent_unique_id": "research-copilot",
+        "agent_timeout": 19,
+        "session_timeout": 19,
+        "filters": {"agent_uid": agent_uid},
+    }
+    assert out == [FakeAgentSession().model_dump()]
+
+
 def test_get_agent_session_uses_client_model(cli_mod, monkeypatch):
     api_mod = importlib.import_module("mainsequence.cli.api")
     captured = {}
@@ -7385,6 +7486,59 @@ def test_agent_get_latest_session(cli_mod, runner, monkeypatch):
     assert "prompt_tokens" in result.output
 
 
+def test_agent_session_list_scoped_by_agent_uid(cli_mod, runner, monkeypatch):
+    captured = {}
+    monkeypatch.setattr(cli_mod, "_require_login", lambda: {"username": "u"})
+    agent_uid = "e0e75693-4110-464c-93e0-82c7fd9c9a23"
+    session_uid = "3f1cc452-43ec-49cb-b2ba-87dbac164d29"
+
+    def _list_agent_sessions(*, timeout=None, filters=None, agent_uid=None, agent_unique_id=None):
+        captured["timeout"] = timeout
+        captured["filters"] = filters
+        captured["agent_uid"] = agent_uid
+        captured["agent_unique_id"] = agent_unique_id
+        return [
+            {
+                "uid": session_uid,
+                "agent_uid": agent_uid,
+                "agent_name": "Research Copilot",
+                "status": "running",
+                "runtime_state": "connected",
+                "started_at": "2026-04-11T09:15:00Z",
+                "name": "Rates check",
+            }
+        ]
+
+    monkeypatch.setattr(cli_mod, "list_agent_sessions", _list_agent_sessions)
+
+    result = runner.invoke(
+        cli_mod.app,
+        [
+            "agent",
+            "session",
+            "list",
+            "--agent-uid",
+            agent_uid,
+            "--filter",
+            "status=running",
+            "--timeout",
+            "12",
+        ],
+    )
+    assert result.exit_code == 0
+    assert captured == {
+        "timeout": 12,
+        "filters": {"status": "running"},
+        "agent_uid": agent_uid,
+        "agent_unique_id": None,
+    }
+    assert "Agent Sessions" in result.output
+    assert "3f1cc45" in result.output
+    assert "Copilot" in result.output
+    assert "connect" in result.output
+    assert "Total agent sessions: 1" in result.output
+
+
 def test_agent_session_detail(cli_mod, runner, monkeypatch):
     monkeypatch.setattr(cli_mod, "_require_login", lambda: {"username": "u"})
     monkeypatch.setattr(

{mainsequence-4.4.11 → mainsequence-4.4.12}/tests/test_filter_normalization.py

@@ -1473,6 +1473,34 @@ def test_agent_session_runtime_access_uses_session_uid_route(monkeypatch):
                 "mode": "token",
                 "rpc_url": "https://runtime.main-sequence.app/rpc",
                 "token": "tok-secret",
+                "is_ready": True,
+                "knative_service_runtime_uid": "70c6efb9-8e80-4051-ad3a-f432b2c37f5a",
+                "image_drift": {
+                    "agent_kind": "astro_orchestrator",
+                    "available": True,
+                    "has_drift": False,
+                    "autoheal_available": False,
+                    "autoheal_message": "No automatic drift repair is needed.",
+                    "checks": [
+                        {
+                            "key": "orchestrator_image",
+                            "label": "Orchestrator image",
+                            "status": "match",
+                            "has_drift": False,
+                            "matches": True,
+                            "reason": "match",
+                            "message": "The runtime image matches the catalog image.",
+                            "autoheal_supported": True,
+                            "autoheal_mode": "request_driven_runtime_sync",
+                            "autoheal_message": "No runtime repair is needed.",
+                            "expected_image_uri": "registry.example/astro@sha256:expected",
+                            "actual_image_uri": "registry.example/astro@sha256:expected",
+                            "expected_commit_hash": "",
+                            "actual_commit_hash": "",
+                        }
+                    ],
+                    "detail": None,
+                },
             }
 
     def _fake_make_request(*, s, loaders, r_type, url, payload, time_out=None):
@@ -1487,6 +1515,11 @@ def test_agent_session_runtime_access_uses_session_uid_route(monkeypatch):
     access = agent_models_mod.AgentSession.resolve_runtime_access(session_uid, timeout=11)
 
     assert access.coding_agent_service_id == "svc-12"
+    assert access.is_ready is True
+    assert access.knative_service_runtime_uid == "70c6efb9-8e80-4051-ad3a-f432b2c37f5a"
+    assert access.image_drift is not None
+    assert access.image_drift.agent_kind == "astro_orchestrator"
+    assert access.image_drift.checks[0].key == "orchestrator_image"
     assert captured == {
         "r_type": "POST",
         "url": f"{agent_models_mod.AgentSession.get_object_url()}/{session_uid}/resolve_runtime_access/",