wexa-sdk 0.1.0__py3-none-any.whl → 0.1.6__py3-none-any.whl

wexa_sdk/agentflows.py

@@ -1,5 +1,24 @@
+from __future__ import annotations
+from typing import Optional, TypedDict
 from .core.http import HttpClient
 
+
+class AgentflowCreateBody(TypedDict, total=False):
+    """Body for creating an AgentFlow (Coworker).
+
+    Required:
+      - name: str
+      - description: str
+      - role: str
+      - projectID: str
+
+    Optional: backend-supported fields like agents/processflow, anomaly_detection, cron_details, etc.
+    """
+    name: str
+    description: str
+    role: str
+    projectID: str
+
 class AgentFlows:
     def __init__(self, http: HttpClient):
         self.http = http
@@ -27,11 +46,77 @@ class AgentFlows:
     def get(self, id: str):
         return self.http.request("GET", f"/agentflow/{id}")
 
-    def create(self, body: dict):
-        return self.http.request("POST", "/agentflow/", json=body)
+    def create(self, body: AgentflowCreateBody, projectID: Optional[str] = None):
+        """
+        Create a new AgentFlow (Coworker).
+
+        Query params:
+          - projectID (str, required): Project to create the AgentFlow in. If not provided
+            as an argument, this will be inferred from body['projectID'] or body['projectId'].
+
+        Headers:
+          - x-api-key (str, required)
+
+        Body (application/json):
+          - name (str, required)
+          - description (str, required)
+          - role (str, required)
+          - projectID (str, required)
+          - ...additional optional fields supported by backend (e.g., agents, anomaly_detection, cron_details)
+
+        Returns:
+          - dict: The created AgentFlow JSON (e.g., keys: _id, name, role, projectID, ...)
+        """
+        # include projectID in query if provided, or infer from body
+        pid = projectID or body.get("projectID") or body.get("projectId")
+        params = {"projectID": pid} if pid else None
+        return self.http.request("POST", "/agentflow/", params=params, json=body)
 
     def update(self, id: str, body: dict):
         return self.http.request("PUT", f"/agentflow/{id}", json=body)
 
-    def delete(self, project_id: str, id: str):
-        return self.http.request("DELETE", f"/agentflow/{project_id}/{id}")
+    # Typed body for updating a skilled agent to enable IDE suggestions
+    class UpdateSkilledAgentBody(TypedDict, total=False):
+        """Body for updating a skilled agent within an AgentFlow.
+
+        Required (per API docs):
+          - role: str
+          - title: str
+          - skills: list[str]
+          - prompt: { template: str, variables: list, display_template: str }
+          - context: list
+          - triggers: list
+          - llm: { model: str, max_tokens: int, temperature: int }
+          - role_description: str
+          - memory: { memory_type: str }
+          - has_knowledge_base: bool
+          - is_user_specific_task: bool
+          - is_preview_mode_enabled: bool
+        """
+        role: str
+        title: str
+        skills: list[str]
+        prompt: dict
+        context: list
+        triggers: list
+        llm: dict
+        role_description: str
+        memory: dict
+        has_knowledge_base: bool
+        is_user_specific_task: bool
+        is_preview_mode_enabled: bool
+
+    def update_skilled_agent(self, agentflow_id: str, agent_id: str, *, projectID: str, body: UpdateSkilledAgentBody | dict):
+        """Update a skilled agent within an AgentFlow.
+
+        Endpoint: POST /agentflow/{agentflow_id}/update/skilled/{agent_id}?projectID=...
+
+        Args:
+            agentflow_id: ID of the AgentFlow
+            agent_id: ID of the skilled agent inside the AgentFlow
+            projectID: Project ID (query param, required)
+            body: Update payload, see UpdateSkilledAgentBody for suggested keys
+        """
+        params = {"projectID": projectID} if projectID else None
+        path = f"/agentflow/{agentflow_id}/update/skilled/{agent_id}"
+        return self.http.request("POST", path, params=params, json=body)

wexa_sdk/connectors/core.py

@@ -1,9 +1,35 @@
 from __future__ import annotations
-from typing import Any, Optional
+from typing import Any, Optional, TypedDict
 
 from ..core.http import HttpClient
 from .google_drive import GoogleDrive
 
+class ConnectorConfigBody(TypedDict, total=False):
+    """JSON body for configuring a connector via POST /actions/{CATEGORY}/config.
+
+    Required by backend (typical fields):
+      - name: str
+      - description: str
+      - category: str
+      - org_id: str
+      - projectID: str           # NOTE: camelCase as required by backend
+      - logo: str
+      - ui_form: list
+
+    Optional/variable:
+      - config: dict
+      - enabled: bool
+    """
+    name: str
+    description: str
+    category: str
+    org_id: str
+    projectID: str
+    logo: str
+    ui_form: list
+    config: dict
+    enabled: bool
+
 class Connectors:
     def __init__(self, http: HttpClient):
         self.http = http
@@ -16,8 +42,10 @@ class Connectors:
         return self.http.request("POST", path, params=params, json=body)
 
     # POST /actions/{CATEGORY}/config?projectID=...
-    def set_config(self, category: str, project_id: str, body: dict) -> Any:
-        return self.http.request("POST", f"/actions/{category}/config", params={"projectID": project_id}, json=body)
+    def set_config(self, category: str, project_id: str, body: ConnectorConfigBody | dict) -> Any:
+        # Ensure body contains the required camelCase field expected by the backend
+        json_body = {**(body or {}), "projectID": project_id}
+        return self.http.request("POST", f"/actions/{category}/config", params={"projectID": project_id}, json=json_body)
 
     # GET /actions/{CATEGORY}/config/{projectID}
     def get_config(self, category: str, project_id: str) -> Any:

wexa_sdk/core/__init__.py

@@ -0,0 +1 @@
+from .http import HttpClient, ApiError

wexa_sdk/core/http.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+import json
+import time
+from typing import Any, Dict, Optional
+
+import httpx
+
+RETRY_STATUS = {429, 500, 502, 503, 504}
+
+class ApiError(Exception):
+    def __init__(self, status: int, detail: Optional[str] = None, code: Optional[str] = None, request_id: Optional[str] = None, raw: Any = None):
+        super().__init__(detail or f"API Error {status}")
+        self.status = status
+        self.code = code
+        self.detail = detail
+        self.request_id = request_id
+        self.raw = raw
+
+class HttpClient:
+    def __init__(self, base_url: str, api_key: str, user_agent: Optional[str] = None, timeout: Optional[dict] = None, retries: Optional[dict] = None):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.user_agent = user_agent
+        self.timeout = {
+            "connectTimeoutMs": (timeout or {}).get("connectTimeoutMs", 5000),
+            "readTimeoutMs": (timeout or {}).get("readTimeoutMs", 30000),
+        }
+        self.retries = {
+            "attempts": (retries or {}).get("attempts", 3),
+            "baseDelayMs": (retries or {}).get("baseDelayMs", 500),
+            "maxDelayMs": (retries or {}).get("maxDelayMs", 30000),
+        }
+        self._client = httpx.Client(timeout=self.timeout["readTimeoutMs"] / 1000)
+
+    def request(self, method: str, path: str, *, params: Optional[Dict[str, Any]] = None, json: Any = None, headers: Optional[Dict[str, str]] = None):
+        url = f"{self.base_url}{path}"
+        hdrs = {
+            "content-type": "application/json",
+            "x-api-key": self.api_key,
+            "X-Wexa-SDK-Version": "py/0.1.0",
+        }
+        if self.user_agent:
+            hdrs["User-Agent"] = self.user_agent
+        if headers:
+            hdrs.update(headers)
+
+        req_id = headers.get("x-client-request-id") if headers else None
+        if not req_id:
+            req_id = str(int(time.time() * 1000))
+        hdrs["x-client-request-id"] = req_id
+
+        attempt = 0
+        last_err: Optional[Exception] = None
+        while attempt < self.retries["attempts"]:
+            try:
+                resp = self._client.request(method, url, params=params, json=json, headers=hdrs)
+                res_req_id = resp.headers.get("x-request-id") or req_id
+                text = resp.text
+                try:
+                    data = resp.json() if text else None
+                except Exception:
+                    data = text
+                if not resp.is_success:
+                    detail = (isinstance(data, dict) and (data.get("detail") or data.get("error") or data.get("message"))) or text or f"HTTP {resp.status_code}"
+                    if resp.status_code in RETRY_STATUS and attempt < self.retries["attempts"] - 1:
+                        time.sleep(self._backoff(attempt) / 1000)
+                        attempt += 1
+                        continue
+                    raise ApiError(status=resp.status_code, detail=detail, request_id=res_req_id, raw=data)
+                return data
+            except ApiError:
+                raise
+            except Exception as e:  # network error
+                last_err = e
+                if attempt < self.retries["attempts"] - 1:
+                    time.sleep(self._backoff(attempt) / 1000)
+                    attempt += 1
+                    continue
+                raise ApiError(status=0, detail=str(e), request_id=req_id, raw=e)
+        raise last_err  # type: ignore
+
+    def _backoff(self, attempt: int) -> int:
+        import random
+        jitter = random.random() * 0.2 + 0.9
+        delay = min(self.retries["maxDelayMs"], int(self.retries["baseDelayMs"] * (2 ** attempt)))
+        return int(delay * jitter)

wexa_sdk/files.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, TypedDict
 
 from .core.http import HttpClient
 
@@ -9,7 +9,14 @@ class Files:
 
     # POST /files/upload?projectID=...&container_name=...
     # body example: { "filenames": ["file.pdf"], "tags": ["resume"], "source_type": "STORAGE", "org_id": "..." }
-    def upload_request(self, project_id: str, container_name: str, body: Dict[str, Any]):
+    class UploadFilesBody(TypedDict):
+        filenames: list[str]
+        tags: list[str]
+        projectID: str
+        source_type: str
+        org_id: str
+
+    def upload_request(self, project_id: str, container_name: str, body: UploadFilesBody):
         params: Dict[str, Any] = {"projectID": project_id, "container_name": container_name}
         return self.http.request("POST", "/files/upload", params=params, json=body)
 

wexa_sdk/projects.py

@@ -1,33 +1,133 @@
 from __future__ import annotations
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, TypedDict
 
 from .core.http import HttpClient
 
+
+class ProjectCreateBody(TypedDict, total=False):
+    """Body for creating a project.
+
+    Required fields:
+      - orgId: str
+      - projectName: str
+
+    Optional fields:
+      - description: str
+      - coworker_role: str
+      - status: str (e.g., "published")
+    """
+    orgId: str
+    projectName: str
+    description: str
+    coworker_role: str
+    status: str
+
 class Projects:
     def __init__(self, http: HttpClient):
         self.http = http
 
     # Per developers.wexa.ai: POST https://api.wexa.ai/v1/project
-    def create(self, body: Dict[str, Any]):
+    def create(self, body: ProjectCreateBody):
         """
-        Expected body (example):
+        Create a project with a request body.
+
+        Example body:
         {
           "orgId": "67fdea40aac77be632954f0f",
           "projectName": "New",
           "description": "yoooo",
-          "coworker_role": "testrole"
+          "coworker_role": "testrole",
+          "status": "published"
         }
         """
         return self.http.request("POST", "/v1/project", json=body)
 
+    def create_simple(
+        self,
+        *,
+        orgId: str,
+        projectName: str,
+        description: Optional[str] = None,
+        coworker_role: Optional[str] = None,
+        status: Optional[str] = None,
+    ):
+        """Convenience wrapper: builds the body and calls create(body)."""
+        body: Dict[str, Any] = {"orgId": orgId, "projectName": projectName}
+        if description is not None:
+            body["description"] = description
+        if coworker_role is not None:
+            body["coworker_role"] = coworker_role
+        if status is not None:
+            body["status"] = status
+        return self.create(body)  # type: ignore[arg-type]
+
     def list(self):
         return self.http.request("GET", "/v1/project")
 
+    def list_all(self, user_id: str):
+        """
+        Get all projects for a given user (organization-wide).
+        GET /v1/project/all?userId=...
+
+        Headers:
+          - x-api-key: string (required)
+
+        Query params:
+          - userId: string (required)
+        """
+        params = {"userId": user_id}
+        return self.http.request("GET", "/v1/project/all", params=params)
+
+    def get_all(
+        self,
+        *,
+        status: Optional[str] = None,
+        user_id: Optional[str] = None,
+        org_id: Optional[str] = None,
+        page: Optional[int] = None,
+        limit: Optional[int] = None,
+    ):
+        """
+        Get all projects with optional filters and pagination.
+        GET /v1/project?status=...&userId=...&orgId=...&page=...&limit=...
+
+        Args:
+            status: Optional project status filter (e.g., "published").
+            user_id: Optional user filter.
+            org_id: Optional organization filter.
+            page: Optional page number (int).
+            limit: Optional page size (int).
+        """
+        params: Dict[str, Any] = {}
+        if status is not None:
+            params["status"] = status
+        if user_id is not None:
+            params["userId"] = user_id
+        if org_id is not None:
+            params["orgId"] = org_id
+        if page is not None:
+            params["page"] = page
+        if limit is not None:
+            params["limit"] = limit
+
+        return self.http.request("GET", "/v1/project", params=params)
+
     def get(self, project_id: str):
         return self.http.request("GET", f"/v1/project/{project_id}")
 
-    def update(self, project_id: str, body: Dict[str, Any]):
-        return self.http.request("PUT", f"/v1/project/{project_id}", json=body)
+    class ProjectUpdateBody(TypedDict):
+        orgId: str
+        projectName: str
+        description: str
+        coworker_role: str
+
+    def update(self, project_id: str, body: ProjectUpdateBody):
+        """Update a project via PUT /v1/project?projectId=... with required fields.
+
+        Required body keys: orgId, projectName, description, coworker_role
+        """
+        params = {"projectId": project_id}
+        return self.http.request("PUT", "/v1/project", params=params, json=body)
 
     def delete(self, project_id: str):
         return self.http.request("DELETE", f"/v1/project/{project_id}")

wexa_sdk/skills.py

@@ -1,19 +1,41 @@
 from __future__ import annotations
-from typing import Any, Dict, Optional
+from typing import Optional, TypedDict, Dict, Any
 
 from .core.http import HttpClient
 
+
+class SkillCreateBody(TypedDict):
+    """Body for creating a Skill.
+
+    Required (user_id can be null but key is required):
+      - name: str
+      - logo: str
+      - connector_name: str
+      - description: str
+      - projectID: str
+      - connector_id: str
+      - user_id: Optional[str]
+    """
+    name: str
+    logo: str
+    connector_name: str
+    description: str
+    projectID: str
+    connector_id: str
+    user_id: Optional[str]
+
+
 class Skills:
     def __init__(self, http: HttpClient):
         self.http = http
 
     # POST /skills/
-    def create(self, body: Dict[str, Any]):
+    def create(self, body: SkillCreateBody):
         return self.http.request("POST", "/skills/", json=body)
 
     # GET /skills/?projectID=...&limit=...
     def list(self, project_id: str, *, limit: Optional[int] = None):
-        params: Dict[str, Any] = {"projectID": project_id}
+        params = {"projectID": project_id}
         if limit is not None:
             params["limit"] = limit
         return self.http.request("GET", "/skills/", params=params)

wexa_sdk/tables.py

@@ -1,14 +1,70 @@
 from __future__ import annotations
-from typing import Any, Optional
+from typing import Any, Optional, TypedDict, List, Dict, Union
 
 from .core.http import HttpClient
 
+class ObjectField(TypedDict, total=False):
+    """Field descriptor for object-type columns."""
+    key: str
+    keyType: str
+
+
+class AgentflowTrigger(TypedDict, total=False):
+    """Trigger configuration attached to a table or column.
+
+    Note: exact schemas for `condition` and `filters` may evolve; we leave them open.
+    """
+    _id: str
+    id: str
+    condition: Dict[str, Any]
+    name: Optional[str]
+    goal: str
+    agentflow_id: Optional[str]
+    filters: List[Dict[str, Any]]
+    schedule_time: Optional[str]
+    event: str
+    start_from_agent_id: Optional[str]
+    trigger_type: str  # e.g. "coworker"
+
+
+class Column(TypedDict, total=False):
+    """Column definition for a table."""
+    column_name: str
+    column_type: str
+    column_id: str
+    array_type: Optional[str]
+    default_value: Union[Any, List[Any], Dict[str, Any]]
+    object_fields: List[ObjectField]
+    triggers: List[AgentflowTrigger]
+    enum_options: List[str]
+
+
+class CreateTableInput(TypedDict, total=False):
+    """Typed input for creating a table.
+
+    Required keys: projectID, table_name
+    Optional keys: columns, triggers
+    """
+    projectID: str
+    table_name: str
+    columns: List[Column]
+    triggers: List[AgentflowTrigger]
+
+
 class Tables:
     def __init__(self, http: HttpClient):
         self.http = http
 
     # Tables
-    def create_table(self, project_id: str, spec: dict):
+    def create_table(self, project_id: str, spec: CreateTableInput):
+        """Create a new table.
+
+        Args:
+            project_id: The project ID (placed into query as `projectID`).
+            spec: Table specification containing at least `table_name`.
+
+        The backend expects `projectID` in both query params and JSON body.
+        """
         # API expects projectID as query param and in body with 'projectID' casing
         params = {"projectID": project_id}
         body = {"projectID": project_id, **spec}

{wexa_sdk-0.1.0.dist-info → wexa_sdk-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wexa-sdk
-Version: 0.1.0
+Version: 0.1.6
 Summary: Official Wexa Python SDK
 Author: Wexa
 License: Apache-2.0

{wexa_sdk-0.1.0.dist-info → wexa_sdk-0.1.6.dist-info}/RECORD

@@ -1,22 +1,24 @@
 wexa_sdk/__init__.py,sha256=dNvZ0fU4v0clBOuZWdd02SLxVfrBF2Ig-efQMOweq-I,1627
-wexa_sdk/agentflows.py,sha256=LQ-W5YISsXe32IZp8xcSy6rtxpeVSIOMqqI1E2rlHkg,1259
+wexa_sdk/agentflows.py,sha256=G6F0TLTiSYFC0b9vJhHl-uClOhE9nXGjDENmiTz99FU,4351
 wexa_sdk/analytics.py,sha256=PVWvRvuyxOAbwxxAoILquESyb2Jw3cJGogbBu2ATRH4,345
 wexa_sdk/connectors_mgmt.py,sha256=7vCT4ilez2YjZnfFEzb0raglTwweqxomqtJOb36RVT4,2229
 wexa_sdk/executions.py,sha256=-bVXo7ESA8AYZtc-tPDi28qWKJg_eYEQCo1kSYgE1P8,2509
-wexa_sdk/files.py,sha256=SitroFP9M5Ut-y00iulRScRvzu4TGIRRbCiRGYo5f9E,1063
+wexa_sdk/files.py,sha256=K2m6gxs_8XDhlW4W08DhSc-HwrMx3r2S5dOFvltLTqc,1235
 wexa_sdk/inbox.py,sha256=aKFmST2FX09mDYXyrqNpUYTsq6z0iJG4qtsCeMWKPdo,1957
 wexa_sdk/marketplace.py,sha256=jhpeSWLU_BLFJcbwx_vcLeUff3UEPkylyhVIm_Fcb5Y,1609
 wexa_sdk/project_members.py,sha256=TssDroghwYMsPRibZ1dNvKynzMtgIUN1TDFsmc2AuW4,514
-wexa_sdk/projects.py,sha256=OV-hLsCYRL9coKmxO4I2M5YMXwX6cAzKtePpcn8TH1s,1035
+wexa_sdk/projects.py,sha256=RkatvCK-IdBXk5pc71HAkCi08p04ez_04nBbsMMpogs,4031
 wexa_sdk/settings.py,sha256=TDnqYeFBvrrj9kznTUTJxG29sJ02bHxBlqE55DgIfTg,290
-wexa_sdk/skills.py,sha256=71Az2xJ39dy6noBmeoHKxHGtd1tY6n4Zzkbf0YxFu9A,1357
-wexa_sdk/tables.py,sha256=JYGK1zWRWZgZGbiRyv-ko3XKdpxZv0piwb02h0v5ODw,2753
+wexa_sdk/skills.py,sha256=ZOFdspJsns_X88nBMrhaFWWcTKuh5afk0hK73-Qzs9M,1799
+wexa_sdk/tables.py,sha256=nS2QMePJEkEC-VzrIIZLmf8LruqD83PfjyDHif5vEZE,4307
 wexa_sdk/tasks.py,sha256=YRXMxQwgpiflAxyUqedyo4LB6bsO7zsiM5uP0uE8_Ds,1349
 wexa_sdk/connectors/__init__.py,sha256=eEtSQ8oXlYnoD3CUxPCF3Il6bgGyN6zfKI3_Pu41jXo,51
-wexa_sdk/connectors/core.py,sha256=4dFp0CVCysUsIOT7l9V7bzXu1jRx9EBGZv2_bQkKPsQ,1188
+wexa_sdk/connectors/core.py,sha256=7ghbFAPR1emgBL9PWStDp6AgZ5JDkiBWXQGaZ0B5Fek,1978
 wexa_sdk/connectors/google_drive.py,sha256=Dibfoy8uKcGygmjCnrolPhKq5Fy5ye5-ee_kI4XD7kY,945
+wexa_sdk/core/__init__.py,sha256=K-bUeDdR3iblN9BNwMQ-ZMbOcAJSAUkNwuoVz5L3fC4,39
+wexa_sdk/core/http.py,sha256=4O59C5VlVhxaQNkjJ0UpARZk3g-rEoOxEbwE0u9NWbY,3721
 wexa_sdk/models/__init__.py,sha256=yxQUjah8RTJh531y8QQXEeh5dp0d5k55dsrVvR4O1N8,75
-wexa_sdk-0.1.0.dist-info/METADATA,sha256=WZEHzNIIMLoIwp6B7E1ctiOf9V9nekaiDclogl4DsQg,581
-wexa_sdk-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-wexa_sdk-0.1.0.dist-info/top_level.txt,sha256=iXL6c0Kro-mkIoNbjT76txRuoilWB-P7AHhmvKtdXkA,9
-wexa_sdk-0.1.0.dist-info/RECORD,,
+wexa_sdk-0.1.6.dist-info/METADATA,sha256=Jux9cTUOZgJbd2TNMREAyVwev-v8-k29eV1Kvs-JgJA,581
+wexa_sdk-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+wexa_sdk-0.1.6.dist-info/top_level.txt,sha256=iXL6c0Kro-mkIoNbjT76txRuoilWB-P7AHhmvKtdXkA,9
+wexa_sdk-0.1.6.dist-info/RECORD,,