persona-sdk-python 0.1.0__py3-none-any.whl

persona_sdk/__init__.py

@@ -0,0 +1,32 @@
+from persona_sdk.client import PersonaClient
+from persona_sdk.api.agents import AgentsApi
+from persona_sdk.api.workflows import WorkflowsApi
+from persona_sdk.api.triggers import TriggersApi
+from persona_sdk.api.sessions import SessionsApi
+from persona_sdk.api.credentials import CredentialsApi
+from persona_sdk.api.knowledge_bases import KnowledgeBasesApi
+from persona_sdk.api.projects import ProjectsApi
+from persona_sdk.api.features import FeaturesApi
+from persona_sdk.api.missions import MissionsApi
+from persona_sdk.api.service_prices import ServicePricesApi
+
+
+class PersonaSdk:
+    def __init__(self, base_url: str, api_key: str, workflows_url: str = None):
+        self.client = PersonaClient(base_url, api_key)
+        self.workflows_client = PersonaClient(workflows_url, api_key) if workflows_url else self.client
+        self.agents = AgentsApi(self.client)
+        self.workflows = WorkflowsApi(self.workflows_client)
+        self.triggers = TriggersApi(self.client)
+        self.sessions = SessionsApi(self.client)
+        self.credentials = CredentialsApi(self.client)
+        self.knowledge_bases = KnowledgeBasesApi(self.client)
+        self.projects = ProjectsApi(self.client)
+        self.features = FeaturesApi(self.client)
+        self.missions = MissionsApi(self.client)
+        self.service_prices = ServicePricesApi(self.client)
+
+    async def close(self):
+        await self.client.close()
+        if self.workflows_client is not self.client:
+            await self.workflows_client.close()

persona_sdk/api/agents.py

@@ -0,0 +1,27 @@
+from persona_sdk.client import PersonaClient
+
+
+class AgentsApi:
+    def __init__(self, client: PersonaClient):
+        self._client = client
+
+    async def list(self, keyword: str = None, page: int = 1, size: int = 20) -> dict:
+        params = {"page": page, "size": size}
+        if keyword:
+            params["keyword"] = keyword
+        return await self._client.get("/agents", params=params)
+
+    async def get(self, agent_id: str) -> dict:
+        return await self._client.get(f"/agents/{agent_id}")
+
+    async def create(self, agent: dict) -> dict:
+        return await self._client.post("/agents", json=agent)
+
+    async def update(self, agent_id: str, agent: dict) -> dict:
+        return await self._client.put(f"/agents/{agent_id}", json=agent)
+
+    async def delete(self, agent_id: str) -> dict:
+        return await self._client.delete(f"/agents/{agent_id}")
+
+    async def get_voices(self, synthesizer_type: str) -> dict:
+        return await self._client.get(f"/values/synthesizers/{synthesizer_type}/voices")

persona_sdk/api/credentials.py

@@ -0,0 +1,21 @@
+from persona_sdk.client import PersonaClient
+
+
+class CredentialsApi:
+    def __init__(self, client: PersonaClient):
+        self._client = client
+
+    async def list(self) -> dict:
+        return await self._client.get("/credentials")
+
+    async def list_by_provider(self, provider: str) -> dict:
+        return await self._client.get(f"/credentials/{provider}")
+
+    async def get(self, credentials_id: str) -> dict:
+        return await self._client.get(f"/credentials/all/{credentials_id}")
+
+    async def authorize(self, provider: str, request: dict) -> dict:
+        return await self._client.post(f"/credentials/{provider}/authorize", json=request)
+
+    async def delete(self, credentials_id: str) -> dict:
+        return await self._client.delete(f"/credentials/all/{credentials_id}")

persona_sdk/api/features.py

@@ -0,0 +1,27 @@
+from persona_sdk.client import PersonaClient
+
+
+class FeaturesApi:
+    def __init__(self, client: PersonaClient):
+        self._client = client
+
+    async def list(self, keyword: str = None, page: int = 1, size: int = 20) -> dict:
+        params = {"page": page, "size": size}
+        if keyword:
+            params["keyword"] = keyword
+        return await self._client.get("/features/templates", params=params)
+
+    async def get(self, template_id: str) -> dict:
+        return await self._client.get(f"/features/templates/{template_id}")
+
+    async def create(self, feature_template: dict) -> dict:
+        return await self._client.post("/features/templates", json=feature_template)
+
+    async def update(self, template_id: str, feature_template: dict) -> dict:
+        return await self._client.put(f"/features/templates/{template_id}", json=feature_template)
+
+    async def delete(self, template_id: str) -> dict:
+        return await self._client.delete(f"/features/templates/{template_id}")
+
+    async def get_mcp_tools(self, mcp_config: dict) -> dict:
+        return await self._client.post("/features/templates/mcp/available-tools", json=mcp_config)

persona_sdk/api/knowledge_bases.py

@@ -0,0 +1,34 @@
+from persona_sdk.client import PersonaClient
+
+
+class KnowledgeBasesApi:
+    def __init__(self, client: PersonaClient):
+        self._client = client
+
+    async def list(self, keyword: str = None, page: int = 1, size: int = 20) -> dict:
+        params = {"page": page, "size": size}
+        if keyword:
+            params["keyword"] = keyword
+        return await self._client.get("/knowledges", params=params)
+
+    async def get(self, knowledge_base_id: str) -> dict:
+        return await self._client.get(f"/knowledges/{knowledge_base_id}")
+
+    async def create(self, knowledge_base: dict) -> dict:
+        return await self._client.post("/knowledges", json=knowledge_base)
+
+    async def update(self, knowledge_base_id: str, knowledge_base: dict) -> dict:
+        return await self._client.put(f"/knowledges/{knowledge_base_id}", json=knowledge_base)
+
+    async def delete(self, knowledge_base_id: str) -> dict:
+        return await self._client.delete(f"/knowledges/{knowledge_base_id}")
+
+    async def list_documents(self, knowledge_base_id: str, page: int = 1, size: int = 20) -> dict:
+        params = {"page": page, "size": size}
+        return await self._client.get(f"/knowledges/{knowledge_base_id}/documents", params=params)
+
+    async def delete_document(self, knowledge_base_id: str, document_id: str) -> dict:
+        return await self._client.delete(f"/knowledges/{knowledge_base_id}/documents/{document_id}")
+
+    async def search_chunks(self, knowledge_base_id: str, request: dict) -> dict:
+        return await self._client.post(f"/knowledges/{knowledge_base_id}/search", json=request)

persona_sdk/api/missions.py

@@ -0,0 +1,41 @@
+from persona_sdk.client import PersonaClient
+
+
+class MissionsApi:
+    def __init__(self, client: PersonaClient):
+        self._client = client
+
+    async def list(self, keyword: str = None, status: str = None, page: int = 1, size: int = 20) -> dict:
+        params = {"page": page, "size": size}
+        if keyword:
+            params["keyword"] = keyword
+        if status:
+            params["status"] = status
+        return await self._client.get("/missions", params=params)
+
+    async def get(self, mission_id: str) -> dict:
+        return await self._client.get(f"/missions/{mission_id}")
+
+    async def create(self, mission: dict) -> dict:
+        return await self._client.post("/missions", json=mission)
+
+    async def update(self, mission_id: str, mission: dict) -> dict:
+        return await self._client.put(f"/missions/{mission_id}", json=mission)
+
+    async def delete(self, mission_id: str) -> dict:
+        return await self._client.delete(f"/missions/{mission_id}")
+
+    async def generate(self, mission_id: str) -> dict:
+        return await self._client.post(f"/missions/{mission_id}/generate")
+
+    async def execute(self, mission_id: str) -> dict:
+        return await self._client.post(f"/missions/{mission_id}/execute")
+
+    async def continue_mission(self, mission_id: str) -> dict:
+        return await self._client.post(f"/missions/{mission_id}/continue")
+
+    async def stop(self, mission_id: str) -> dict:
+        return await self._client.post(f"/missions/{mission_id}/stop")
+
+    async def send_instructions(self, mission_id: str, instructions: dict) -> dict:
+        return await self._client.post(f"/missions/{mission_id}/instructions", json=instructions)

persona_sdk/api/projects.py

@@ -0,0 +1,27 @@
+from persona_sdk.client import PersonaClient
+
+
+class ProjectsApi:
+    def __init__(self, client: PersonaClient):
+        self._client = client
+
+    async def list(self, keyword: str = None, page: int = 1, size: int = 20) -> dict:
+        params = {"page": page, "size": size}
+        if keyword:
+            params["keyword"] = keyword
+        return await self._client.get("/projects", params=params)
+
+    async def get(self, project_id: str) -> dict:
+        return await self._client.get(f"/projects/{project_id}")
+
+    async def get_mine(self) -> dict:
+        return await self._client.get("/projects/mine")
+
+    async def create(self, project: dict) -> dict:
+        return await self._client.post("/projects", json=project)
+
+    async def update(self, project_id: str, project: dict) -> dict:
+        return await self._client.put(f"/projects/{project_id}", json=project)
+
+    async def delete(self, project_id: str) -> dict:
+        return await self._client.delete(f"/projects/{project_id}")

persona_sdk/api/service_prices.py

@@ -0,0 +1,24 @@
+from persona_sdk.client import PersonaClient
+
+
+class ServicePricesApi:
+    def __init__(self, client: PersonaClient):
+        self._client = client
+
+    async def list(self, keyword: str = None, page: int = 1, size: int = 20) -> dict:
+        params = {"page": page, "size": size}
+        if keyword:
+            params["keyword"] = keyword
+        return await self._client.get("/service-prices", params=params)
+
+    async def get(self, service_price_id: str) -> dict:
+        return await self._client.get(f"/service-prices/{service_price_id}")
+
+    async def create(self, service_price: dict) -> dict:
+        return await self._client.post("/service-prices", json=service_price)
+
+    async def update(self, service_price_id: str, service_price: dict) -> dict:
+        return await self._client.put(f"/service-prices/{service_price_id}", json=service_price)
+
+    async def delete(self, service_price_id: str) -> dict:
+        return await self._client.delete(f"/service-prices/{service_price_id}")

persona_sdk/api/sessions.py

@@ -0,0 +1,42 @@
+from persona_sdk.client import PersonaClient
+
+
+class SessionsApi:
+    def __init__(self, client: PersonaClient):
+        self._client = client
+
+    async def list(
+        self,
+        keyword: str = None,
+        status: str = None,
+        agent_id: str = None,
+        user_id: str = None,
+        page: int = 1,
+        size: int = 20,
+    ) -> dict:
+        params = {"page": page, "size": size}
+        if keyword:
+            params["keyword"] = keyword
+        if status:
+            params["status"] = status
+        if agent_id:
+            params["agentId"] = agent_id
+        if user_id:
+            params["userId"] = user_id
+        return await self._client.get("/sessions", params=params)
+
+    async def get(self, session_id: str) -> dict:
+        return await self._client.get(f"/sessions/{session_id}")
+
+    async def get_usage(self, session_id: str) -> dict:
+        return await self._client.get(f"/sessions/{session_id}/usage")
+
+    async def generate_message(self, code: str, request: dict) -> dict:
+        return await self._client.post(f"/sessions/{code}/messages", json=request)
+
+    async def get_messages(self, code: str, page: int = 1, size: int = 20) -> dict:
+        params = {"page": page, "size": size}
+        return await self._client.get(f"/sessions/{code}/messages", params=params)
+
+    async def delete(self, code: str) -> dict:
+        return await self._client.delete(f"/sessions/{code}")

persona_sdk/api/triggers.py

@@ -0,0 +1,34 @@
+from persona_sdk.client import PersonaClient
+
+
+class TriggersApi:
+    def __init__(self, client: PersonaClient):
+        self._client = client
+
+    async def list(self, keyword: str = None, page: int = 1, size: int = 20) -> dict:
+        params = {"page": page, "size": size}
+        if keyword:
+            params["keyword"] = keyword
+        return await self._client.get("/triggers", params=params)
+
+    async def get(self, trigger_id: str) -> dict:
+        return await self._client.get(f"/triggers/{trigger_id}")
+
+    async def create(self, trigger: dict) -> dict:
+        return await self._client.post("/triggers", json=trigger)
+
+    async def update(self, trigger_id: str, trigger: dict) -> dict:
+        return await self._client.put(f"/triggers/{trigger_id}", json=trigger)
+
+    async def delete(self, trigger_id: str) -> dict:
+        return await self._client.delete(f"/triggers/{trigger_id}")
+
+    async def execute(self, trigger_id: str) -> dict:
+        return await self._client.post(f"/triggers/{trigger_id}/executions")
+
+    async def list_executions(self, trigger_id: str, page: int = 1, size: int = 20) -> dict:
+        params = {"page": page, "size": size}
+        return await self._client.get(f"/triggers/{trigger_id}/executions", params=params)
+
+    async def get_execution(self, execution_id: str) -> dict:
+        return await self._client.get(f"/triggers/executions/{execution_id}")

persona_sdk/api/workflows.py

@@ -0,0 +1,34 @@
+from persona_sdk.client import PersonaClient
+
+
+class WorkflowsApi:
+    def __init__(self, client: PersonaClient):
+        self._client = client
+
+    async def list(self, keyword: str = None, page: int = 1, size: int = 20) -> dict:
+        params = {"page": page, "size": size}
+        if keyword:
+            params["keyword"] = keyword
+        return await self._client.get("/workflows", params=params)
+
+    async def get(self, workflow_id: str) -> dict:
+        return await self._client.get(f"/workflows/{workflow_id}")
+
+    async def create(self, workflow: dict) -> dict:
+        return await self._client.post("/workflows", json=workflow)
+
+    async def update(self, workflow_id: str, workflow: dict) -> dict:
+        return await self._client.put(f"/workflows/{workflow_id}", json=workflow)
+
+    async def delete(self, workflow_id: str) -> dict:
+        return await self._client.delete(f"/workflows/{workflow_id}")
+
+    async def execute(self, workflow_id: str, data: dict = None) -> dict:
+        return await self._client.post(f"/workflows/{workflow_id}/execute", json=data or {})
+
+    async def queue(self, workflow_id: str, data: dict = None) -> dict:
+        return await self._client.post(f"/workflows/{workflow_id}/queue", json=data or {})
+
+    async def list_executions(self, workflow_id: str, page: int = 1, size: int = 20) -> dict:
+        params = {"page": page, "size": size}
+        return await self._client.get(f"/workflows/{workflow_id}/executions", params=params)

persona_sdk/client.py

@@ -0,0 +1,50 @@
+import httpx
+
+
+class PersonaClient:
+    """
+    HTTP client for the Persona API.
+
+    Args:
+        base_url: The base URL of the Persona API (e.g. http://localhost:8000).
+        api_key: The API key or JWT token for authentication.
+            The x-persona-apikey header accepts both plain API keys and JWT tokens.
+            JWT tokens are automatically detected and validated by the server.
+    """
+
+    def __init__(self, base_url: str, api_key: str):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self._client = httpx.AsyncClient(
+            base_url=self.base_url,
+            headers={"x-persona-apikey": self.api_key},
+            timeout=30.0,
+        )
+
+    async def get(self, path: str, params: dict = None) -> dict:
+        response = await self._client.get(path, params=params)
+        response.raise_for_status()
+        return response.json()
+
+    async def post(self, path: str, json: dict = None) -> dict:
+        response = await self._client.post(path, json=json)
+        response.raise_for_status()
+        return response.json()
+
+    async def put(self, path: str, json: dict = None) -> dict:
+        response = await self._client.put(path, json=json)
+        response.raise_for_status()
+        return response.json()
+
+    async def patch(self, path: str, json: dict = None) -> dict:
+        response = await self._client.patch(path, json=json)
+        response.raise_for_status()
+        return response.json()
+
+    async def delete(self, path: str) -> dict:
+        response = await self._client.delete(path)
+        response.raise_for_status()
+        return response.json()
+
+    async def close(self):
+        await self._client.aclose()

persona_sdk/runners/__init__.py

@@ -0,0 +1,3 @@
+from persona_sdk.runners.agent_runner import AgentRunner
+from persona_sdk.runners.tool_invoker import ToolInvoker
+from persona_sdk.runners.resource_retriever import ResourceRetriever

persona_sdk/runners/agent_runner.py

@@ -0,0 +1,70 @@
+import logging
+from typing import Optional, Union, List
+
+from pydantic import BaseModel
+
+from persona_models import AgentResponse, GenerationResponse
+from persona_models.common import create_uuid
+from persona_models.mcp import GenerationRequest
+from persona_models.sessions import AgentContext, Message, SessionType
+from persona_sdk.client import PersonaClient
+
+logger = logging.getLogger(__name__)
+
+
+class AgentRunner:
+    def __init__(
+        self,
+        client: PersonaClient,
+        agent_id: str,
+        session_code: Optional[str] = None,
+        parent_session_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        session_type: SessionType = "async",
+    ):
+        self._client = client
+        self.agent_id = agent_id
+        self.session_code = session_code or create_uuid()
+        self.parent_session_id = parent_session_id
+        self.user_id = user_id
+        self.session_type = session_type
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        pass
+
+    async def run(
+        self,
+        request: Union[str, Message, List[Message]],
+        response_schema: Optional[type[BaseModel]] = None,
+        context: AgentContext = None,
+    ) -> AgentResponse | None:
+        user_message = request
+        if isinstance(request, Message):
+            user_message = request.model_dump(by_alias=True)
+        elif isinstance(request, list):
+            user_message = [m.model_dump(by_alias=True) for m in request]
+
+        gen_request = GenerationRequest(
+            agent_id=self.agent_id,
+            parent_session_id=self.parent_session_id,
+            user_id=self.user_id,
+            user_message=user_message,
+            initial_context=context.model_dump(by_alias=True) if context else None,
+            response_schema=(
+                response_schema.model_json_schema() if response_schema else None
+            ),
+        )
+
+        try:
+            response_data = await self._client.post(
+                f"/sessions/{self.session_code}/messages",
+                json=gen_request.model_dump(by_alias=True),
+            )
+            generation_response = GenerationResponse.model_validate(response_data)
+            return generation_response.response
+        except Exception as e:
+            logger.error(f"Error from Persona API: {e}")
+            return None

persona_sdk/runners/resource_retriever.py

@@ -0,0 +1,68 @@
+import logging
+
+from persona_models.common import create_uuid
+from persona_models.mcp import RetrieveResourceRequest, RetrieveResourceResponse, McpTransport
+from persona_sdk.client import PersonaClient
+
+logger = logging.getLogger(__name__)
+
+
+class ResourceRetriever:
+    @staticmethod
+    async def retrieve(
+        client: PersonaClient,
+        mcp_server_name: str,
+        transport: McpTransport,
+        uri: str,
+        session_id: str = None,
+        user_id: str = None,
+        billing_disabled: bool = False,
+    ) -> str | dict | None:
+        request = RetrieveResourceRequest(
+            mcp_server_name=mcp_server_name,
+            transport=transport,
+            uri=uri,
+            session_id=session_id or create_uuid("resource-retrieve"),
+            user_id=user_id,
+            billing_disabled=billing_disabled,
+        )
+
+        response_data = await client.post(
+            "/mcp/resources/retrieve",
+            json=request.model_dump(by_alias=True),
+        )
+
+        result = RetrieveResourceResponse.model_validate(response_data)
+
+        if result.contents:
+            for content in result.contents:
+                if isinstance(content, dict):
+                    if "blob" in content:
+                        return {
+                            "content": content.get("blob"),
+                            "content_type": content.get("mimeType"),
+                        }
+                    elif "text" in content:
+                        return content.get("text")
+
+        return None
+
+
+async def retrieve_resource(
+    client: PersonaClient,
+    mcp_server_name: str,
+    transport: McpTransport,
+    uri: str,
+    session_id: str = None,
+    user_id: str = None,
+    billing_disabled: bool = False,
+) -> str | dict | None:
+    return await ResourceRetriever.retrieve(
+        client=client,
+        mcp_server_name=mcp_server_name,
+        transport=transport,
+        uri=uri,
+        session_id=session_id,
+        user_id=user_id,
+        billing_disabled=billing_disabled,
+    )

persona_sdk/runners/tool_invoker.py

@@ -0,0 +1,59 @@
+import logging
+
+from persona_models.common import create_uuid
+from persona_models.mcp import ToolInvokeRequest, ToolInvokeResponse, McpTransport
+from persona_sdk.client import PersonaClient
+
+logger = logging.getLogger(__name__)
+
+
+class ToolInvoker:
+    @staticmethod
+    async def invoke(
+        client: PersonaClient,
+        mcp_server_name: str,
+        transport: McpTransport,
+        tool_name: str,
+        args: dict = None,
+        session_id: str = None,
+        user_id: str = None,
+        billing_disabled: bool = False,
+    ) -> ToolInvokeResponse:
+        request = ToolInvokeRequest(
+            mcp_server_name=mcp_server_name,
+            transport=transport,
+            tool_name=tool_name,
+            args=args or {},
+            session_id=session_id or create_uuid("tool-invoke"),
+            user_id=user_id,
+            billing_disabled=billing_disabled,
+        )
+
+        response_data = await client.post(
+            "/mcp/tools/invoke",
+            json=request.model_dump(by_alias=True),
+        )
+
+        return ToolInvokeResponse.model_validate(response_data)
+
+
+async def invoke_tool(
+    client: PersonaClient,
+    mcp_server_name: str,
+    transport: McpTransport,
+    tool_name: str,
+    args: dict = None,
+    session_id: str = None,
+    user_id: str = None,
+    billing_disabled: bool = False,
+) -> ToolInvokeResponse:
+    return await ToolInvoker.invoke(
+        client=client,
+        mcp_server_name=mcp_server_name,
+        transport=transport,
+        tool_name=tool_name,
+        args=args,
+        session_id=session_id,
+        user_id=user_id,
+        billing_disabled=billing_disabled,
+    )

persona_sdk_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: persona-sdk-python
+Version: 0.1.0
+Summary: Python SDK client for Persona AI platform
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: persona-models>=0.1.0

persona_sdk_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+persona_sdk/__init__.py,sha256=LJldOXaAvV9-60pclsKbgk7HDb3Rvx3mgXhoBqZbYdM,1513
+persona_sdk/client.py,sha256=8C2gWeVZVvmM58qycL3l2DFBxXeRss0YSRwJDhP_4PQ,1707
+persona_sdk/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+persona_sdk/api/agents.py,sha256=LO-e_keKlZhIpsMMAvYuWTHKh3aypHYRXnD1LSUqCu8,1027
+persona_sdk/api/credentials.py,sha256=fe2D2IH2p4K7kDDZJF5VQfYBNSgYqAe7hfgOsl5ha_I,792
+persona_sdk/api/features.py,sha256=6jMCn66RYsfSg9rP_KWLdemoBHN4dW6_PrbvHAvQweI,1159
+persona_sdk/api/knowledge_bases.py,sha256=8W78AfegdpzhDOOzM6GI3JFYXvC1-Tjc_G2nxjWCuG0,1605
+persona_sdk/api/missions.py,sha256=zAuj5-W5KQ7Y424tfSmut_kpScbgb5zV-lmwN7BuyG8,1688
+persona_sdk/api/projects.py,sha256=1HN6M91wWa_UQJJZFQwi3kZT3ukBDnAeMyoFgyU9aSs,1001
+persona_sdk/api/service_prices.py,sha256=r60Sr2Pu9BDSlFqyDSElV2-93ofKrQN6PVAsv4LPX6s,1001
+persona_sdk/api/sessions.py,sha256=5tA6OYbvkj4E9yIQ6XvX2z5XSO6M8-nyuvrr_4qqs58,1430
+persona_sdk/api/triggers.py,sha256=0AGQlc9wgtZgNbLl-7De8ntHAVj4ZlS-W2BHflof-GA,1410
+persona_sdk/api/workflows.py,sha256=WtSzN2p6YtXa-tE157aQu5kuZaAR1QavgZD0FR3EBMY,1488
+persona_sdk/runners/__init__.py,sha256=GzO-IwwCp7VeBVWLAQFDeg30Q8SaVBHIWT4Fy8gwl0g,183
+persona_sdk/runners/agent_runner.py,sha256=wztVa44d-9cC0Bg-GVli7YuIy6jnG0j_PL5d017fbyI,2394
+persona_sdk/runners/resource_retriever.py,sha256=_ZsSk8XUpOjqtzLB30xpGFFQ_1gGmlQxlgjSVnpetxw,2032
+persona_sdk/runners/tool_invoker.py,sha256=DVtl45MpEMB5w7gRgW6CsuX97nRUaHosd0vE_pCjVbE,1643
+persona_sdk_python-0.1.0.dist-info/METADATA,sha256=ubAJkpRYZ454rh-cVaHiwucZcBYcB4fkYpvXDs9st9A,203
+persona_sdk_python-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+persona_sdk_python-0.1.0.dist-info/RECORD,,

persona_sdk_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any