mainsequence 6.0.51__tar.gz → 6.0.53__tar.gz

{mainsequence-6.0.51 → mainsequence-6.0.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 6.0.51
+Version: 6.0.53
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: LicenseRef-MainSequence-Proprietary

{mainsequence-6.0.51 → mainsequence-6.0.53}/agent_scaffold/skills/a2a_sdk_execution/SKILL.md

@@ -71,6 +71,9 @@ mainsequence agent session get_or_create \
 ```
 
 Use the returned session `uid` as the target `AgentSession` UID.
+The returned `runtime_capabilities` map is a read-only advertisement from the
+session harness. Inspect it when capability-aware behavior is required; never
+construct, send, or override it from client code.
 
 If this A2A request originates from an existing caller session, include the
 parent session UID:

{mainsequence-6.0.51 → mainsequence-6.0.53}/agent_scaffold/skills/data_publishing/meta_table_migrations/SKILL.md

@@ -108,6 +108,13 @@ platform-managed, Alembic-managed reservations and are validated before HTTP.
 - Do not create SDK reset/reconcile commands for stale reserved state. If stale
   reserved state exists, fail clearly and require an explicit backend/admin
   repair path.
+- Ordinary `MetaTable.delete()` must not bypass Alembic schema-management
+  protection. For a deliberate organization-admin teardown/reset only, use
+  `MetaTable.delete_with_cascade(confirm_cascade_delete=True, ...)` and set
+  `override_schema_management_protection=True` when deleting Alembic-managed
+  tables. Decide explicitly whether referencing MetaTables and time-indexed Data
+  Nodes are also deleted. This permanently deletes catalog rows and physical
+  tables; never use it as migration reconciliation or an Alembic downgrade.
 - Do not write direct backend migration request bodies in examples. Use the CLI
   and SDK provider APIs.
 - Do not call platform-managed model `.register()` in normal application code.

{mainsequence-6.0.51 → mainsequence-6.0.53}/mainsequence/client/agent_runtime_models.py

@@ -1808,6 +1808,13 @@ class AgentSession(OwnerLogMixin, BaseObjectOrm, BasePydanticModel):
         default=None,
         description="Backend-owned application-log capability for this exact session.",
     )
+    runtime_capabilities: dict[str, str] = Field(
+        default_factory=dict,
+        description=(
+            "Read-only versioned runtime capabilities advertised by the session "
+            "harness. Capability names are backend-extensible."
+        ),
+    )
     agent_uid: str | None = Field(
         None, description="Public UID of the agent definition used for this session."
     )

{mainsequence-6.0.51 → mainsequence-6.0.53}/mainsequence/client/metatables/core.py

@@ -1030,6 +1030,67 @@ class ManagedMetaTableFinalizeResponse(BasePydanticModel):
     model_config = ConfigDict(extra="allow")
 
 
+class MetaTableCascadeDeleteRequest(BasePydanticModel):
+    confirm_cascade_delete: Literal[True] = Field(
+        ...,
+        description="Explicit confirmation required for destructive cascade deletion.",
+    )
+    delete_referencing_meta_tables: bool = Field(
+        default=True,
+        description="Delete MetaTables that reference the selected MetaTable.",
+    )
+    delete_referencing_dynamic_tables: bool = Field(
+        default=True,
+        description="Delete time-indexed Data Nodes that reference the selected MetaTable.",
+    )
+    override_schema_management_protection: bool = Field(
+        default=False,
+        description=(
+            "Explicitly allow deletion of Alembic-managed MetaTables. The backend "
+            "still requires organization-admin permission."
+        ),
+    )
+
+    @field_validator("confirm_cascade_delete", mode="before")
+    @classmethod
+    def _require_explicit_confirmation(cls, value: Any) -> Any:
+        if value is not True:
+            raise ValueError("confirm_cascade_delete must be explicitly set to true.")
+        return value
+
+
+class MetaTableCascadeDeletedMetaTable(BasePydanticModel):
+    meta_table_uid: str
+    physical_schema: str | None = None
+    physical_table_name: str | None = None
+    management_mode: MetaTableManagementMode
+    physical_table_drop_scheduled: bool
+    physical_table_drop_cascade: bool
+    schema_management_protection_overridden: bool
+
+
+class MetaTableCascadeDeletedDynamicTable(BasePydanticModel):
+    type: Literal["meta_table"]
+    table_kind: Literal["time_indexed"]
+    time_indexed: Literal[True]
+    uid: str
+    identifier: str | None = None
+    namespace: str | None = None
+    physical_schema: str | None = None
+    physical_table_name: str | None = None
+
+
+class MetaTableCascadeDeleteResponse(BasePydanticModel):
+    ok: Literal[True]
+    action: Literal["delete_with_cascade"]
+    root_meta_table_uid: str
+    deleted_meta_tables: list[MetaTableCascadeDeletedMetaTable]
+    deleted_dynamic_tables: list[MetaTableCascadeDeletedDynamicTable]
+    deleted_meta_table_count: int = Field(..., ge=0)
+    deleted_dynamic_table_count: int = Field(..., ge=0)
+    blocking_edges: list[dict[str, Any]]
+
+
 class DataSource(BasePydanticModel, BaseObjectOrm):
     model_config = ConfigDict(extra="allow")
 
@@ -1558,6 +1619,60 @@ class MetaTable(
             override_protection=override_protection,
         )
 
+    @classmethod
+    def delete_with_cascade_by_uid(
+        cls,
+        uid: str,
+        *,
+        confirm_cascade_delete: bool | None = None,
+        delete_referencing_meta_tables: bool = True,
+        delete_referencing_dynamic_tables: bool = True,
+        override_schema_management_protection: bool = False,
+        timeout: int | float | tuple[float, float] | None = None,
+    ) -> MetaTableCascadeDeleteResponse:
+        if uid in (None, ""):
+            raise ValueError(f"{cls.__name__} uid is required for cascade deletion.")
+        request = MetaTableCascadeDeleteRequest(
+            confirm_cascade_delete=confirm_cascade_delete,
+            delete_referencing_meta_tables=delete_referencing_meta_tables,
+            delete_referencing_dynamic_tables=delete_referencing_dynamic_tables,
+            override_schema_management_protection=override_schema_management_protection,
+        )
+        operation = f"{cls.__name__}.delete_with_cascade"
+        request_payload: dict[str, Any] = {"json": _payload_json(request)}
+        query_context = cls._sdk_owned_query_context(operation)
+        if query_context:
+            request_payload["params"] = query_context
+        response = make_request(
+            s=cls.build_session(),
+            loaders=cls.LOADERS,
+            r_type="POST",
+            url=(f"{cls.get_object_url().rstrip('/')}/{uid}/delete-with-cascade/"),
+            payload=request_payload,
+            time_out=timeout,
+        )
+        if response.status_code != 200:
+            raise_for_response(response, payload=request_payload)
+        return MetaTableCascadeDeleteResponse.model_validate(response.json())
+
+    def delete_with_cascade(
+        self,
+        *,
+        confirm_cascade_delete: bool | None = None,
+        delete_referencing_meta_tables: bool = True,
+        delete_referencing_dynamic_tables: bool = True,
+        override_schema_management_protection: bool = False,
+        timeout: int | float | tuple[float, float] | None = None,
+    ) -> MetaTableCascadeDeleteResponse:
+        return type(self).delete_with_cascade_by_uid(
+            self._public_uid(),
+            confirm_cascade_delete=confirm_cascade_delete,
+            delete_referencing_meta_tables=delete_referencing_meta_tables,
+            delete_referencing_dynamic_tables=delete_referencing_dynamic_tables,
+            override_schema_management_protection=override_schema_management_protection,
+            timeout=timeout,
+        )
+
     @classmethod
     def register(
         cls,
@@ -4967,6 +5082,10 @@ __all__ = [
     "ManagedMetaTableCollectionCreateRow",
     "ManagedTimeIndexMetaTableCollectionCreateRow",
     "MetaTable",
+    "MetaTableCascadeDeleteRequest",
+    "MetaTableCascadeDeleteResponse",
+    "MetaTableCascadeDeletedDynamicTable",
+    "MetaTableCascadeDeletedMetaTable",
     "MetaTableMigrationConnection",
     "MetaTableMigrationConnectionRequest",
     "MetaTableColumnContract",

{mainsequence-6.0.51 → mainsequence-6.0.53}/mainsequence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 6.0.51
+Version: 6.0.53
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: LicenseRef-MainSequence-Proprietary

{mainsequence-6.0.51 → mainsequence-6.0.53}/pyproject.toml

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

{mainsequence-6.0.51 → mainsequence-6.0.53}/tests/test_environment_response_contracts.py

@@ -109,3 +109,8 @@ def test_backend_environment_response_contract_is_declared_by_strict_sdk_model(
 def test_owner_observability_projection_is_declared_by_strict_sdk_model(model):
     assert model.model_config.get("extra") == "forbid"
     assert "observability" in model.model_fields
+
+
+def test_agent_session_runtime_capabilities_projection_is_declared_and_typed():
+    assert agent_models.AgentSession.model_config.get("extra") == "forbid"
+    assert agent_models.AgentSession.model_fields["runtime_capabilities"].annotation == dict[str, str]

{mainsequence-6.0.51 → mainsequence-6.0.53}/tests/test_filter_normalization.py

@@ -1832,6 +1832,18 @@ def test_agent_runtime_models_deserialize_backend_uid_payloads():
                 "owner_user_uid": user_uid,
                 "is_locked": False,
             },
+            "observability": {
+                "application_logs_url": f"/api/v1/agent-sessions/{session_uid}/logs/",
+                "resource_usage_url": None,
+                "deployment_runs_url": None,
+                "sessions_url": None,
+            },
+            "runtime_capabilities": {
+                "tau_runtime_bootstrap": "v1",
+                "tau_resume_snapshot": "v1",
+                "tau_activity_sequence": "v1",
+                "tau_turn_commit": "v1",
+            },
         }
     )
     assert session.uid == session_uid
@@ -1842,6 +1854,13 @@ def test_agent_runtime_models_deserialize_backend_uid_payloads():
     assert session.harness_version == "0.3.1"
     assert session.is_archived is False
     assert session.active_model == "gpt-5.4"
+    assert session.observability.application_logs_url.endswith(f"/{session_uid}/logs/")
+    assert session.runtime_capabilities == {
+        "tau_runtime_bootstrap": "v1",
+        "tau_resume_snapshot": "v1",
+        "tau_activity_sequence": "v1",
+        "tau_turn_commit": "v1",
+    }
 
     service = agent_models_mod.CodingAgentService.model_validate(
         {
@@ -2089,6 +2108,70 @@ def test_agent_session_filter_supports_archive_history_query(monkeypatch):
     }
 
 
+def test_agent_session_list_and_detail_parse_runtime_capabilities(monkeypatch):
+    session_uid = "3f1cc452-43ec-49cb-b2ba-87dbac164d29"
+    agent_uid = "e0e75693-4110-464c-93e0-82c7fd9c9a23"
+    session_payload = {
+        "uid": session_uid,
+        "agent_uid": agent_uid,
+        "agent_name": "Research Copilot",
+        "agent_type": "custom",
+        "harness": "tau",
+        "harness_protocol": "tau-session-v1",
+        "harness_version": "0.3.1",
+        "name": "Reusable session",
+        "status": "running",
+        "llm_provider": "openai",
+        "llm_model": "gpt-5.4",
+        "llm_thinking": "medium",
+        "observability": {
+            "application_logs_url": f"/api/v1/agent-sessions/{session_uid}/logs/",
+            "resource_usage_url": None,
+            "deployment_runs_url": None,
+            "sessions_url": None,
+        },
+        "runtime_capabilities": {
+            "tau_runtime_bootstrap": "v1",
+            "tau_resume_snapshot": "v1",
+            "tau_activity_sequence": "v1",
+            "tau_turn_commit": "v1",
+        },
+    }
+    responses = iter(
+        [
+            {"count": 1, "next": None, "previous": None, "results": [dict(session_payload)]},
+            dict(session_payload),
+        ]
+    )
+
+    class FakeResponse:
+        status_code = 200
+        content = b'{"ok": true}'
+
+        def __init__(self, payload):
+            self._payload = payload
+
+        def json(self):
+            return self._payload
+
+    def _fake_make_request(*, s, loaders, r_type, url, payload, time_out=None):
+        return FakeResponse(next(responses))
+
+    monkeypatch.setattr(base_mod, "make_request", _fake_make_request)
+
+    listed = agent_models_mod.AgentSession.filter(agent_uid=agent_uid)
+    detailed = agent_models_mod.AgentSession.get(pk=session_uid)
+
+    assert listed[0].runtime_capabilities["tau_turn_commit"] == "v1"
+    assert detailed.runtime_capabilities == listed[0].runtime_capabilities
+    assert detailed.observability.application_logs_url.endswith(f"/{session_uid}/logs/")
+
+    with pytest.raises(ValidationError, match="unexpected_projection"):
+        agent_models_mod.AgentSession.model_validate(
+            {**session_payload, "unexpected_projection": "still forbidden"}
+        )
+
+
 def test_agent_session_get_insights_parses_pi_response(monkeypatch):
     session_uid = "3f1cc452-43ec-49cb-b2ba-87dbac164d29"
     captured = {}
@@ -3990,6 +4073,80 @@ def test_agent_get_or_create_session_posts_new_contract(monkeypatch):
     }
 
 
+def test_agent_get_or_create_session_parses_reused_handle_capabilities(monkeypatch):
+    agent_uid = "e0e75693-4110-464c-93e0-82c7fd9c9a23"
+    session_uid = "3f1cc452-43ec-49cb-b2ba-87dbac164d29"
+    handle_unique_id = "tutorial-evaluation-development"
+    agent = agent_models_mod.Agent(
+        uid=agent_uid,
+        name="Research Copilot",
+        agent_type="custom",
+        description="Research assistant.",
+        agent_card=None,
+        llm_provider="openai",
+        llm_model="gpt-5.4",
+        llm_thinking="medium",
+        repository_branch=None,
+        organization_environment_uid=None,
+        organization_environment_name=None,
+    )
+    captured = {}
+
+    class FakeResponse:
+        status_code = 200
+        content = b'{"ok": true}'
+
+        @staticmethod
+        def json():
+            return {
+                "uid": session_uid,
+                "agent_uid": agent_uid,
+                "agent_name": "Research Copilot",
+                "agent_type": "custom",
+                "harness": "tau",
+                "harness_protocol": "tau-session-v1",
+                "harness_version": "0.3.1",
+                "name": "Tutorial evaluation",
+                "status": "running",
+                "llm_provider": "openai",
+                "llm_model": "gpt-5.4",
+                "llm_thinking": "medium",
+                "bound_handle": {
+                    "uid": "44444444-4444-4444-8444-444444444444",
+                    "handle_unique_id": handle_unique_id,
+                    "owner_user_uid": "fdf409f7-d16f-4f71-986b-9057db6c7eca",
+                    "is_locked": False,
+                },
+                "observability": {
+                    "application_logs_url": f"/api/v1/agent-sessions/{session_uid}/logs/",
+                    "resource_usage_url": None,
+                    "deployment_runs_url": None,
+                    "sessions_url": None,
+                },
+                "runtime_capabilities": {
+                    "tau_runtime_bootstrap": "v1",
+                    "tau_resume_snapshot": "v1",
+                    "tau_activity_sequence": "v1",
+                    "tau_turn_commit": "v1",
+                },
+            }
+
+    def _fake_make_request(*, s, loaders, r_type, url, payload, time_out=None):
+        captured.update({"r_type": r_type, "url": url, "payload": payload, "timeout": time_out})
+        return FakeResponse()
+
+    monkeypatch.setattr(agent_models_mod, "make_request", _fake_make_request)
+
+    session = agent.get_or_create_session(handle_unique_id=handle_unique_id, timeout=13)
+
+    assert session.uid == session_uid
+    assert session.bound_handle["handle_unique_id"] == handle_unique_id
+    assert session.runtime_capabilities["tau_runtime_bootstrap"] == "v1"
+    assert session.observability.application_logs_url.endswith(f"/{session_uid}/logs/")
+    assert captured["payload"] == {"json": {"handle_unique_id": handle_unique_id}}
+    assert captured["timeout"] == 13
+
+
 def test_agent_get_or_create_session_by_uid_sends_only_session_uid(monkeypatch):
     captured = {}
     agent_uid = "e0e75693-4110-464c-93e0-82c7fd9c9a23"

{mainsequence-6.0.51 → mainsequence-6.0.53}/tests/test_meta_tables_client_models.py

@@ -8,6 +8,7 @@ from pydantic import ValidationError
 
 import mainsequence.client.metatables as meta_table_models
 import mainsequence.project_context as project_context
+from mainsequence.client.exceptions import ConflictError, PermissionDeniedError
 from mainsequence.meta_tables.compiled_sql.v1 import build_operation, compile_sqlalchemy_statement
 
 ENVIRONMENT_UID = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb"
@@ -88,6 +89,162 @@ def _project_context():
     )
 
 
+def _cascade_delete_response():
+    return {
+        "ok": True,
+        "action": "delete_with_cascade",
+        "root_meta_table_uid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+        "deleted_meta_tables": [
+            {
+                "meta_table_uid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+                "physical_schema": "public",
+                "physical_table_name": "example_assets__asset",
+                "management_mode": "platform_managed",
+                "physical_table_drop_scheduled": True,
+                "physical_table_drop_cascade": True,
+                "schema_management_protection_overridden": True,
+            }
+        ],
+        "deleted_dynamic_tables": [
+            {
+                "type": "meta_table",
+                "table_kind": "time_indexed",
+                "time_indexed": True,
+                "uid": "cccccccc-cccc-4ccc-8ccc-cccccccccccc",
+                "identifier": "AssetPrices",
+                "namespace": "example.assets",
+                "physical_schema": "public",
+                "physical_table_name": "example_assets__asset_prices",
+            }
+        ],
+        "deleted_meta_table_count": 1,
+        "deleted_dynamic_table_count": 1,
+        "blocking_edges": [
+            {
+                "relationship_type": "meta_table_to_meta_table",
+                "source_table_kind": "time_indexed",
+            }
+        ],
+    }
+
+
+def test_meta_table_confirmed_cascade_delete_posts_typed_contract(monkeypatch):
+    captured = {}
+
+    def fake_make_request(**kwargs):
+        captured.update(kwargs)
+        return _Response(_cascade_delete_response())
+
+    monkeypatch.setattr(meta_table_models, "make_request", fake_make_request)
+    monkeypatch.setattr(
+        meta_table_models.MetaTable,
+        "build_session",
+        classmethod(lambda cls: SimpleNamespace(headers={})),
+    )
+    meta_table = meta_table_models.MetaTable(
+        **_meta_table_response(
+            schema_management_mode="alembic_managed",
+            migration_provider_key="example:assets",
+        )
+    )
+
+    result = meta_table.delete_with_cascade(
+        confirm_cascade_delete=True,
+        delete_referencing_meta_tables=False,
+        delete_referencing_dynamic_tables=True,
+        override_schema_management_protection=True,
+        timeout=19,
+    )
+
+    assert isinstance(result, meta_table_models.MetaTableCascadeDeleteResponse)
+    assert result.root_meta_table_uid == meta_table.uid
+    assert result.deleted_meta_table_count == 1
+    assert result.deleted_dynamic_tables[0].table_kind == "time_indexed"
+    assert captured["r_type"] == "POST"
+    assert captured["url"].endswith(f"/meta-tables/{meta_table.uid}/delete-with-cascade/")
+    assert captured["payload"] == {
+        "json": {
+            "confirm_cascade_delete": True,
+            "delete_referencing_meta_tables": False,
+            "delete_referencing_dynamic_tables": True,
+            "override_schema_management_protection": True,
+        },
+        "params": {"organization_environment_uid": ENVIRONMENT_UID},
+    }
+    assert captured["time_out"] == 19
+
+
+@pytest.mark.parametrize("confirmation", [None, False, 1, "true"])
+def test_meta_table_cascade_delete_requires_explicit_true_confirmation(
+    monkeypatch,
+    confirmation,
+):
+    monkeypatch.setattr(
+        meta_table_models,
+        "make_request",
+        lambda **kwargs: pytest.fail("missing confirmation must fail before HTTP"),
+    )
+
+    with pytest.raises(ValidationError, match="confirm_cascade_delete"):
+        meta_table_models.MetaTable.delete_with_cascade_by_uid(
+            "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+            confirm_cascade_delete=confirmation,
+        )
+
+
+@pytest.mark.parametrize(
+    ("status_code", "error_type", "detail"),
+    [
+        (
+            403,
+            PermissionDeniedError,
+            "Only organization admins can perform this destructive MetaTable action.",
+        ),
+        (
+            409,
+            ConflictError,
+            "Alembic-managed MetaTables require schema-management override.",
+        ),
+    ],
+)
+def test_meta_table_cascade_delete_preserves_typed_backend_errors(
+    monkeypatch,
+    status_code,
+    error_type,
+    detail,
+):
+    captured = {}
+
+    def fake_make_request(**kwargs):
+        captured.update(kwargs)
+        return _Response(
+            {
+                "ok": False,
+                "code": "permission_denied"
+                if status_code == 403
+                else "alembic_managed_delete_blocked",
+                "detail": detail,
+            },
+            status_code=status_code,
+        )
+
+    monkeypatch.setattr(meta_table_models, "make_request", fake_make_request)
+
+    with pytest.raises(error_type, match=detail) as error:
+        meta_table_models.MetaTable.delete_with_cascade_by_uid(
+            "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+            confirm_cascade_delete=True,
+            override_schema_management_protection=True,
+        )
+
+    assert error.value.status_code == status_code
+    assert error.value.payload["code"] in {
+        "permission_denied",
+        "alembic_managed_delete_blocked",
+    }
+    assert captured["payload"]["params"] == {"organization_environment_uid": ENVIRONMENT_UID}
+
+
 @pytest.mark.parametrize(
     "legacy_field",
     ["organization_environment_uid", "project_uid", "repository_branch"],