agentstack-sdk 0.5.2rc2__py3-none-any.whl

agentstack_sdk/platform/user_feedback.py

@@ -0,0 +1,42 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+from datetime import datetime
+from uuid import UUID
+
+import pydantic
+
+from agentstack_sdk.platform.client import PlatformClient, get_platform_client
+from agentstack_sdk.platform.common import PaginatedResult
+from agentstack_sdk.util.utils import filter_dict
+
+
+class UserFeedback(pydantic.BaseModel):
+    id: UUID
+    provider_id: UUID
+    task_id: UUID
+    context_id: UUID
+    rating: int
+    message: str
+    comment: str | None = None
+    comment_tags: list[str] | None = None
+    created_at: datetime
+    agent_name: str
+
+    @staticmethod
+    async def list(
+        *,
+        provider_id: str | None = None,
+        limit: int = 50,
+        after_cursor: str | None = None,
+        client: PlatformClient | None = None,
+    ) -> "ListUserFeedbackResponse":
+        async with client or get_platform_client() as client:
+            params = filter_dict({"provider_id": provider_id, "limit": limit, "after_cursor": after_cursor})
+            return pydantic.TypeAdapter(ListUserFeedbackResponse).validate_python(
+                (await client.get(url="/api/v1/user_feedback", params=params)).raise_for_status().json()
+            )
+
+
+class ListUserFeedbackResponse(PaginatedResult[UserFeedback]):
+    pass

agentstack_sdk/platform/variables.py

@@ -0,0 +1,44 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from agentstack_sdk.platform.client import PlatformClient, get_platform_client
+
+
+class Variables(dict[str, str]):
+    async def save(
+        self: Variables | dict[str, str | None] | dict[str, str],
+        *,
+        client: PlatformClient | None = None,
+    ) -> None:
+        """
+        Save variables to the Agent Stack platform. Does not delete keys unless explicitly set to None.
+
+        Can be used as a class method: Variables.save({"key": "value", ...})
+        ...or as an instance method: variables.save()
+        """
+        async with client or get_platform_client() as client:
+            _ = (
+                await client.put(
+                    url="/api/v1/variables",
+                    json={"variables": self},
+                )
+            ).raise_for_status()
+
+    async def load(self: Variables | None = None, *, client: PlatformClient | None = None) -> Variables:
+        """
+        Load variables from the Agent Stack platform.
+
+        Can be used as a class method: variables = Variables.load()
+        ...or as an instance method to update the instance: variables.load()
+        """
+        async with client or get_platform_client() as client:
+            new_variables: dict[str, str] = (
+                (await client.get(url="/api/v1/variables")).raise_for_status().json()["variables"]
+            )
+        if isinstance(self, Variables):
+            self.clear()
+            self.update(new_variables)
+            return self
+        return Variables(new_variables)

agentstack_sdk/platform/vector_store.py

@@ -0,0 +1,217 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import typing
+import uuid
+from typing import Literal, Self
+
+import pydantic
+
+from agentstack_sdk.platform.client import PlatformClient, get_platform_client
+from agentstack_sdk.platform.types import Metadata
+
+
+class VectorStoreStats(pydantic.BaseModel):
+    usage_bytes: int
+    num_documents: int
+
+
+class VectorStoreDocument(pydantic.BaseModel):
+    id: str
+    vector_store_id: str
+    file_id: str | None = None
+    usage_bytes: int | None = None
+    created_at: pydantic.AwareDatetime
+
+
+class VectorStoreItem(pydantic.BaseModel):
+    id: str = pydantic.Field(default_factory=lambda: uuid.uuid4().hex)
+    document_id: str
+    document_type: typing.Literal["platform_file", "external"] | None = "platform_file"
+    model_id: str | typing.Literal["platform"] = "platform"
+    text: str
+    embedding: list[float]
+    metadata: Metadata | None = None
+
+    @pydantic.model_validator(mode="after")
+    def validate_document_id(self) -> Self:
+        """Validate that document_id is a valid UUID when document_type is platform_file."""
+        if self.document_type == "platform_file":
+            try:
+                _ = uuid.UUID(self.document_id)
+            except ValueError as ex:
+                raise ValueError(
+                    f"document_id must be a valid UUID when document_type is platform_file, got: {self.document_id}"
+                ) from ex
+        return self
+
+
+class VectorStoreSearchResult(pydantic.BaseModel):
+    item: VectorStoreItem
+    score: float
+
+
+class VectorStore(pydantic.BaseModel):
+    id: str
+    name: str | None = None
+    model_id: str
+    dimension: int
+    created_at: pydantic.AwareDatetime
+    last_active_at: pydantic.AwareDatetime
+    created_by: str
+    stats: VectorStoreStats | None = None
+
+    @staticmethod
+    async def create(
+        *,
+        name: str,
+        dimension: int,
+        model_id: str,
+        client: PlatformClient | None = None,
+        context_id: str | None | Literal["auto"] = "auto",
+    ) -> VectorStore:
+        async with client or get_platform_client() as platform_client:
+            context_id = platform_client.context_id if context_id == "auto" else context_id
+            return pydantic.TypeAdapter(VectorStore).validate_json(
+                (
+                    await platform_client.post(
+                        url="/api/v1/vector_stores",
+                        json={"name": name, "dimension": dimension, "model_id": model_id},
+                        params=context_id and {"context_id": context_id},
+                    )
+                )
+                .raise_for_status()
+                .content
+            )
+
+    async def get(
+        self: VectorStore | str,
+        /,
+        *,
+        client: PlatformClient | None = None,
+        context_id: str | None | Literal["auto"] = "auto",
+    ) -> VectorStore:
+        # `self` has a weird type so that you can call both `instance.get()` to update an instance, or `VectorStore.get("123")` to obtain a new instance
+        vector_store_id = self if isinstance(self, str) else self.id
+        async with client or get_platform_client() as platform_client:
+            context_id = platform_client.context_id if context_id == "auto" else context_id
+            result = pydantic.TypeAdapter(VectorStore).validate_json(
+                (
+                    await platform_client.get(
+                        url=f"/api/v1/vector_stores/{vector_store_id}",
+                        params=context_id and {"context_id": context_id},
+                    )
+                )
+                .raise_for_status()
+                .content
+            )
+        if isinstance(self, VectorStore):
+            self.__dict__.update(result.__dict__)
+            return self
+        return result
+
+    async def delete(
+        self: VectorStore | str,
+        /,
+        *,
+        client: PlatformClient | None = None,
+        context_id: str | None | Literal["auto"] = "auto",
+    ) -> None:
+        # `self` has a weird type so that you can call both `instance.delete()` or `VectorStore.delete("123")`
+        vector_store_id = self if isinstance(self, str) else self.id
+        async with client or get_platform_client() as platform_client:
+            context_id = platform_client.context_id if context_id == "auto" else context_id
+            _ = (
+                await platform_client.delete(
+                    url=f"/api/v1/vector_stores/{vector_store_id}",
+                    params=context_id and {"context_id": context_id},
+                )
+            ).raise_for_status()
+
+    async def add_documents(
+        self: VectorStore | str,
+        /,
+        items: list[VectorStoreItem],
+        *,
+        client: PlatformClient | None = None,
+        context_id: str | None | Literal["auto"] = "auto",
+    ) -> None:
+        # `self` has a weird type so that you can call both `instance.add_documents()` or `VectorStore.add_documents("123", items)`
+        vector_store_id = self if isinstance(self, str) else self.id
+        async with client or get_platform_client() as platform_client:
+            context_id = platform_client.context_id if context_id == "auto" else context_id
+            _ = (
+                await platform_client.put(
+                    url=f"/api/v1/vector_stores/{vector_store_id}",
+                    json=[item.model_dump(mode="json") for item in items],
+                    params=context_id and {"context_id": context_id},
+                )
+            ).raise_for_status()
+
+    async def search(
+        self: VectorStore | str,
+        /,
+        query_vector: list[float],
+        *,
+        limit: int = 10,
+        client: PlatformClient | None = None,
+        context_id: str | None | Literal["auto"] = "auto",
+    ) -> list[VectorStoreSearchResult]:
+        # `self` has a weird type so that you can call both `instance.search()` to search within an instance, or `VectorStore.search("123", query_vector)`
+        vector_store_id = self if isinstance(self, str) else self.id
+        async with client or get_platform_client() as platform_client:
+            context_id = platform_client.context_id if context_id == "auto" else context_id
+            return pydantic.TypeAdapter(list[VectorStoreSearchResult]).validate_python(
+                (
+                    await platform_client.post(
+                        url=f"/api/v1/vector_stores/{vector_store_id}/search",
+                        json={"query_vector": query_vector, "limit": limit},
+                        params=context_id and {"context_id": context_id},
+                    )
+                )
+                .raise_for_status()
+                .json()["items"]
+            )
+
+    async def list_documents(
+        self: VectorStore | str,
+        /,
+        *,
+        client: PlatformClient | None = None,
+        context_id: str | None | Literal["auto"] = "auto",
+    ) -> list[VectorStoreDocument]:
+        # `self` has a weird type so that you can call both `instance.list_documents()` to list documents in an instance, or `VectorStore.list_documents("123")`
+        vector_store_id = self if isinstance(self, str) else self.id
+        async with client or get_platform_client() as platform_client:
+            context_id = platform_client.context_id if context_id == "auto" else context_id
+            return pydantic.TypeAdapter(list[VectorStoreDocument]).validate_python(
+                (
+                    await platform_client.get(
+                        url=f"/api/v1/vector_stores/{vector_store_id}/documents",
+                        params=context_id and {"context_id": context_id},
+                    )
+                )
+                .raise_for_status()
+                .json()["items"]
+            )
+
+    async def delete_document(
+        self: VectorStore | str,
+        /,
+        document_id: str,
+        *,
+        client: PlatformClient | None = None,
+        context_id: str | None | Literal["auto"] = "auto",
+    ) -> None:
+        # `self` has a weird type so that you can call both `instance.delete_document()` or `VectorStore.delete_document("123", "456")`
+        vector_store_id = self if isinstance(self, str) else self.id
+        async with client or get_platform_client() as platform_client:
+            context_id = platform_client.context_id if context_id == "auto" else context_id
+            _ = (
+                await platform_client.delete(
+                    url=f"/api/v1/vector_stores/{vector_store_id}/documents/{document_id}",
+                    params=context_id and {"context_id": context_id},
+                )
+            ).raise_for_status()

agentstack_sdk/server/__init__.py

@@ -0,0 +1,4 @@
+# Copyright 2025 © BeeAI a Series of LF Projects, LLC
+# SPDX-License-Identifier: Apache-2.0
+
+from agentstack_sdk.server.server import Server as Server