wexa-sdk 0.1.3__tar.gz → 0.1.7__tar.gz

{wexa_sdk-0.1.3 → wexa_sdk-0.1.7}/PKG-INFO

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

{wexa_sdk-0.1.3 → wexa_sdk-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wexa-sdk"
-version = "0.1.3"
+version = "0.1.7"
 description = "Official Wexa Python SDK"
 readme = "README.md"
 requires-python = ">=3.9"

wexa_sdk-0.1.7/tests/test_agentflows_add_skilled_agent.py

@@ -0,0 +1,46 @@
+from wexa_sdk import WexaClient
+
+
+def test_agentflows_add_skilled_agent_requests(monkeypatch):
+    client = WexaClient(base_url="https://api.wexa.ai", api_key="key")
+
+    captured = {}
+
+    def fake_request(method, path, *, params=None, json=None, headers=None):  # type: ignore
+        captured["method"] = method
+        captured["path"] = path
+        captured["params"] = params
+        captured["json"] = json
+        return {"ok": True}
+
+    client.http.request = fake_request  # type: ignore
+
+    body = {
+        "_id": "agent-1",
+        "role": "assistant",
+        "title": "Writer",
+        "skills": ["content_writer"],
+        "context": [],
+        "llm": {"model": "gpt-4o", "max_tokens": 512, "temperature": 0.7},
+        "memory": {"memory_type": "short_term"},
+        "agent_type": "skilled",
+        "role_description": "Creates content",
+        "prompt": {"template": "...", "variables": [], "display_template": "..."},
+        "triggers": [],
+        "has_knowledge_base": False,
+        "is_user_specific_task": False,
+        "is_preview_mode_enabled": False,
+        "conditions": [],
+    }
+
+    resp = client.agentflows.add_skilled_agent(
+        "aflow-123",
+        projectID="proj-1",
+        body=body,
+    )
+
+    assert captured["method"] == "POST"
+    assert captured["path"] == "/agentflow/aflow-123/skilled"
+    assert captured["params"] == {"projectID": "proj-1"}
+    assert captured["json"] == body
+    assert resp == {"ok": True}

wexa_sdk-0.1.7/tests/test_agentflows_update_skilled_live.py

@@ -0,0 +1,46 @@
+import os
+import json
+import pytest
+from wexa_sdk import WexaClient
+
+BASE_URL = os.getenv("WEXA_BASE_URL", "https://api.wexa.ai")
+API_KEY = os.getenv("WEXA_API_KEY") or ""
+PROJECT_ID = os.getenv("PROJECT_ID", "68c3b68b9120a0bdfb281d89")
+AGENTFLOW_ID = os.getenv("AGENTFLOW_ID", "6901def632348b1fae4c0e6a")
+AGENT_ID = os.getenv("AGENT_ID", "6901def7e643a25d472d0952")
+
+# The user-provided payload (trimmed to minimal required where possible)
+PAYLOAD = {
+    "role": "Create Call",
+    "title": "Create a Call",
+    "skills": ["6901dbf973f8d927fe126fad"],
+    "prompt": {
+        "display_template": "...",  # large rich text omitted for brevity
+        "variables": [],
+        "template": "..."
+    },
+    "context": [],
+    "triggers": [],
+    "llm": {"model": "bedrock/eu.anthropic.claude-3-7-sonnet-20250219-v1:0", "max_tokens": 10000, "temperature": 0},
+    "role_description": "Creating a calling agent",
+    "memory": {"memory_type": "lt"},
+    "has_knowledge_base": False,
+    "is_user_specific_task": False,
+    "is_preview_mode_enabled": False,
+}
+
+
+@pytest.mark.integration
+def test_update_skilled_agent_live():
+    if not API_KEY:
+        pytest.skip("Set WEXA_API_KEY to run this live test")
+
+    client = WexaClient(base_url=BASE_URL, api_key=API_KEY)
+    resp = client.agentflows.update_skilled_agent(
+        agentflow_id=AGENTFLOW_ID,
+        agent_id=AGENT_ID,
+        projectID=PROJECT_ID,
+        body=PAYLOAD,
+    )
+    print(json.dumps(resp, indent=2))
+    assert isinstance(resp, dict) or isinstance(resp, list)

wexa_sdk-0.1.7/tests/test_agentflows_update_skilled_unit.py

@@ -0,0 +1,43 @@
+from wexa_sdk import WexaClient
+
+
+def test_agentflows_update_skilled_builds_request(monkeypatch):
+    c = WexaClient(base_url="https://api.wexa.ai", api_key="key")
+    captured = {}
+
+    def fake_request(method, path, *, params=None, json=None, headers=None):  # type: ignore
+        captured["method"] = method
+        captured["path"] = path
+        captured["params"] = params
+        captured["json"] = json
+        return {"ok": True}
+
+    c.http.request = fake_request  # type: ignore
+
+    body = {
+        "role": "assistant",
+        "title": "Create a Call",
+        "skills": ["skill-1"],
+        "prompt": {"template": "t", "variables": [], "display_template": "d"},
+        "context": [],
+        "triggers": [],
+        "llm": {"model": "m", "max_tokens": 1000, "temperature": 0},
+        "role_description": "desc",
+        "memory": {"memory_type": "lt"},
+        "has_knowledge_base": False,
+        "is_user_specific_task": False,
+        "is_preview_mode_enabled": False,
+    }
+
+    resp = c.agentflows.update_skilled_agent(
+        agentflow_id="aflow-1",
+        agent_id="agent-1",
+        projectID="proj-1",
+        body=body,
+    )
+
+    assert captured["method"] == "POST"
+    assert captured["path"] == "/agentflow/aflow-1/update/skilled/agent-1"
+    assert captured["params"] == {"projectID": "proj-1"}
+    assert captured["json"] == body
+    assert resp == {"ok": True}

wexa_sdk-0.1.7/tests/test_connectors_config.py

@@ -0,0 +1,30 @@
+from wexa_sdk import WexaClient
+
+
+def test_connectors_config_endpoints(monkeypatch):
+    c = WexaClient(base_url="https://api.wexa.ai", api_key="key")
+    calls = []
+
+    def fake_request(method, path, *, params=None, json=None, headers=None):  # type: ignore
+        calls.append((method, path, params, json))
+        return {"ok": True}
+
+    c.http.request = fake_request  # type: ignore
+
+    # set config -> POST /actions/{CATEGORY}/config?projectID=...
+    c.connectors.set_config("content_creator", "p1", {"enabled": True})
+    # get config -> GET /actions/{CATEGORY}/config/{projectID}
+    c.connectors.get_config("content_creator", "p1")
+
+    assert calls[0] == (
+        "POST",
+        "/actions/content_creator/config",
+        {"projectID": "p1"},
+        {"enabled": True},
+    )
+    assert calls[1] == (
+        "GET",
+        "/actions/content_creator/config/p1",
+        None,
+        None,
+    )

wexa_sdk-0.1.7/tests/test_connectors_config_live.py

@@ -0,0 +1,58 @@
+import os
+import json
+import time
+import pytest
+from wexa_sdk import WexaClient
+
+BASE_URL = os.getenv("WEXA_BASE_URL", "https://api.wexa.ai")
+API_KEY = os.getenv("WEXA_API_KEY")
+PROJECT_ID = "68c3b68b9120a0bdfb281d89"  # provided
+CATEGORY = "content_creator"
+ORG_ID = os.getenv("WEXA_ORG_ID") or os.getenv("NEXT_PUBLIC_ORG_ID")
+
+
+@pytest.mark.integration
+def test_content_creator_config_live_get_then_set():
+    """
+    Live test for connector config:
+    1) GET /actions/{CATEGORY}/config/{projectID}
+    2) POST /actions/{CATEGORY}/config?projectID=...
+
+    Skips when WEXA_API_KEY or ORG_ID (WEXA_ORG_ID/NEXT_PUBLIC_ORG_ID) is not set.
+    """
+    if not API_KEY:
+        pytest.skip("Set WEXA_API_KEY in the environment to run this live test")
+    if not ORG_ID:
+        pytest.skip("Set WEXA_ORG_ID or NEXT_PUBLIC_ORG_ID to run this live test")
+
+    client = WexaClient(base_url=BASE_URL, api_key=API_KEY)
+
+    # Step 1: GET current config
+    current = client.connectors.get_config(CATEGORY, PROJECT_ID)
+    print(json.dumps({"current": current}, indent=2))
+
+    # Step 2: Build required payload from GET response and env
+    cfg = (current or {}).get("config", {})
+    # Ensure unique name to avoid 'Connector with the same name already exists'
+    base_name = cfg.get("name") or "Content creator"
+    unique_name = f"{base_name}-{int(time.time())}"
+    update_body = {
+        # required by backend
+        "name": unique_name,
+        "description": cfg.get("description") or "",
+        "category": CATEGORY,
+        "org_id": ORG_ID,
+        "projectID": PROJECT_ID,
+        "logo": cfg.get("logo") or "",
+        "ui_form": cfg.get("ui_form") or [],
+        # optional but present in GET; include to be safe
+        "config": cfg.get("config") or {},
+        # toggle
+        "enabled": True,
+    }
+
+    updated = client.connectors.set_config(CATEGORY, PROJECT_ID, update_body)
+    print(json.dumps({"updated": updated}, indent=2))
+
+    # Basic assertions
+    assert isinstance(updated, dict)

wexa_sdk-0.1.7/tests/test_projects_create.py

@@ -0,0 +1,60 @@
+from wexa_sdk import WexaClient
+
+
+def test_projects_create_published(monkeypatch):
+    c = WexaClient(base_url="https://api.wexa.ai", api_key="key")
+    calls = []
+
+    def fake_request(method, path, *, params=None, json=None, headers=None):  # type: ignore
+        calls.append((method, path, params, json))
+        return {"_id": "p123"}
+
+    c.http.request = fake_request  # type: ignore
+
+    body = {
+        "orgId": "o1",
+        "projectName": "My Project",
+        "description": "desc",
+        "coworker_role": "role",
+        "status": "published",
+    }
+
+    res = c.projects.create(body)
+
+    # Assert method, path, and payload
+    assert calls[0][0] == "POST"
+    assert calls[0][1] == "/v1/project"
+    assert calls[0][2] is None  # params
+    assert calls[0][3] == body  # json body
+    assert res == {"_id": "p123"}
+
+
+def test_projects_create_simple_published(monkeypatch):
+    c = WexaClient(base_url="https://api.wexa.ai", api_key="key")
+    calls = []
+
+    def fake_request(method, path, *, params=None, json=None, headers=None):  # type: ignore
+        calls.append((method, path, params, json))
+        return {"_id": "p456"}
+
+    c.http.request = fake_request  # type: ignore
+
+    res = c.projects.create_simple(
+        orgId="o1",
+        projectName="Simple Project",
+        description="desc2",
+        coworker_role="role2",
+        status="published",
+    )
+
+    assert calls[0][0] == "POST"
+    assert calls[0][1] == "/v1/project"
+    assert calls[0][2] is None
+    assert calls[0][3] == {
+        "orgId": "o1",
+        "projectName": "Simple Project",
+        "description": "desc2",
+        "coworker_role": "role2",
+        "status": "published",
+    }
+    assert res == {"_id": "p456"}

wexa_sdk-0.1.7/tests/test_projects_create_live.py

@@ -0,0 +1,41 @@
+import time
+import json
+import pytest
+from wexa_sdk import WexaClient
+
+# ===== Configure for live run =====
+BASE_URL = "https://api.wexa.ai"
+API_KEY = "506af7e9-9309-4fdf-b004-8d4cb09dfc05"
+ORG_ID = "66f3cdde22bc63eb7490e23e"
+
+
+@pytest.mark.integration
+def test_projects_create_live_published():
+    """
+    Live test that creates a new project in the given org with status "published".
+    This will mutate production data.
+
+    To run:
+        pytest -s tests/test_projects_create_live.py
+    """
+    if not API_KEY or "REPLACE_WITH" in API_KEY or not ORG_ID:
+        pytest.skip("Edit BASE_URL, API_KEY, ORG_ID before running this live test")
+
+    c = WexaClient(base_url=BASE_URL, api_key=API_KEY)
+
+    name = f"SDK Create Test {int(time.time())}"
+    body = {
+        "orgId": ORG_ID,
+        "projectName": name,
+        "description": "Created via live integration test",
+        "coworker_role": "Tester",
+        "status": "published",
+    }
+    res = c.projects.create(body)
+
+    print(json.dumps(res, indent=2))
+
+    assert isinstance(res, dict)
+    created = res.get("data", res)
+    assert isinstance(created, dict)
+    assert "_id" in created

wexa_sdk-0.1.7/tests/test_projects_get_all_live.py

@@ -0,0 +1,51 @@
+import pytest
+import json
+from wexa_sdk import WexaClient
+
+# ===== Configure these before running =====
+# Use prod or local API base URL
+BASE_URL = "https://api.wexa.ai"  # or "http://localhost:5000"
+API_KEY = "506af7e9-9309-4fdf-b004-8d4cb09dfc05"
+TEST_USER_ID = "66f3cdde22bc63eb7490e23c"
+TEST_ORG_ID = "66f3cdde22bc63eb7490e23e"
+
+
+@pytest.mark.integration
+def test_projects_get_all_live():
+    """
+    Live integration test for Projects.get_all() against a real API.
+
+    Usage:
+      1) Edit BASE_URL, API_KEY, TEST_USER_ID, TEST_ORG_ID at the top of this file.
+      2) Run: pytest -q tests/test_projects_get_all_live.py
+    """
+    base_url = BASE_URL
+    api_key = API_KEY
+    user_id = TEST_USER_ID
+    org_id = TEST_ORG_ID
+
+    if (not api_key) or ("REPLACE_WITH_API_KEY" in api_key) or (not user_id) or (not org_id):
+        pytest.skip("Edit BASE_URL, API_KEY, TEST_USER_ID, TEST_ORG_ID in this file to run this live test")
+
+    c = WexaClient(base_url=base_url, api_key=api_key)
+    res = c.projects.get_all(
+        status="published",
+        user_id=user_id,
+        org_id=org_id,
+        page=1,
+        limit=12,
+    )
+
+    # Print the response for inspection
+    print(json.dumps(res, indent=2))
+
+    assert isinstance(res, dict)
+
+    # Backend may return either a list wrapper or items/count; accept both
+    if "projectList" in res:
+        assert isinstance(res["projectList"], list)
+        assert "totalCount" in res
+    else:
+        # fallback shape if API differs
+        assert "items" in res
+        assert isinstance(res["items"], list)

wexa_sdk-0.1.7/tests/test_projects_mcpconnectortesting.py

@@ -0,0 +1,25 @@
+import pytest
+from wexa_sdk import WexaClient
+
+
+def test_projects_get_by_project_name_builds_correct_request(monkeypatch):
+    captured = {}
+
+    def fake_request(method, path, *, params=None, json=None, headers=None):
+        captured["method"] = method
+        captured["path"] = path
+        captured["params"] = params
+        captured["json"] = json
+        captured["headers"] = headers
+        return {"ok": True}
+
+    c = WexaClient(base_url="https://testing.api.wexa.ai", api_key="265d37d8-3496-4758-b0d5-dc64cc29b444")
+    monkeypatch.setattr(c.projects.http, "request", fake_request)
+
+    res = c.projects.get_by_project_name("Wexa Recruit")
+
+    assert captured["method"] == "GET"
+    assert captured["path"] == "/project/projectName/Wexa%20Recruit"
+    assert res == {"ok": True}
+
+

wexa_sdk-0.1.7/tests/test_projects_mcpconnectortesting_live.py

@@ -0,0 +1,26 @@
+import os
+import json
+import pytest
+from wexa_sdk import WexaClient
+
+
+# Live test uses provided base URL and API key
+BASE_URL = "https://testing.api.wexa.ai"
+API_KEY = "265d37d8-3496-4758-b0d5-dc64cc29b444"
+
+
+@pytest.mark.integration
+def test_projects_mcp_connector_testing_live():
+    project_name = os.getenv("WEXA_TEST_PROJECT_NAME")
+    if not project_name:
+        pytest.skip("Set WEXA_TEST_PROJECT_NAME to run this live test")
+
+    c = WexaClient(base_url=BASE_URL, api_key=API_KEY)
+    res = c.projects.get_by_project_name(project_name)
+
+    # Print for visibility when running live
+    print(json.dumps(res, indent=2))
+
+    assert res is not None
+
+

{wexa_sdk-0.1.3 → wexa_sdk-0.1.7}/tests/test_tables.py

@@ -12,7 +12,7 @@ def test_tables_endpoints(monkeypatch):
     c.http.request = fake_request  # type: ignore
 
     # Tables
-    c.tables.create_table("proj", {"name": "T"})
+    c.tables.create_table("proj", {"table_name": "T"})
     c.tables.list_tables("proj")
     c.tables.get_table("proj", "tbl")
     c.tables.get_table_view("tbl")
@@ -32,7 +32,7 @@ def test_tables_endpoints(monkeypatch):
     c.tables.bulk_upsert("proj", "tbl", [{"a": 1}])
     c.tables.export("proj", "tbl")
 
-    assert calls[0] == ("POST", "/create/table", {"projectID": "proj"}, {"projectID": "proj", "name": "T"})
+    assert calls[0] == ("POST", "/create/table", {"projectID": "proj"}, {"projectID": "proj", "table_name": "T"})
     assert calls[1] == ("GET", "/storage/proj", None, None)
     assert calls[2] == ("GET", "/storage/proj/tbl", None, None)
     assert calls[3] == ("GET", "/table/view/tbl", None, None)

wexa_sdk-0.1.7/tests/test_tables_create_live.py

@@ -0,0 +1,36 @@
+import os
+import json
+import pytest
+from wexa_sdk import WexaClient
+
+BASE_URL = os.getenv("WEXA_BASE_URL", "https://api.wexa.ai")
+API_KEY = os.getenv("WEXA_API_KEY")
+PROJECT_ID = "68c3b68b9120a0bdfb281d89"  # provided
+
+
+@pytest.mark.integration
+def test_tables_create_live_wexa_sdk():
+    """
+    Live test to create a table with random columns (no triggers).
+    Skips if WEXA_API_KEY is not set.
+    """
+    if not API_KEY:
+        pytest.skip("Set WEXA_API_KEY in your environment to run this live test")
+
+    client = WexaClient(base_url=BASE_URL, api_key=API_KEY)
+
+    table_name = "wexa_sdk"
+    spec = {
+        "table_name": table_name,
+        "columns": [
+            {"column_name": "email", "column_type": "String", "column_id": "email"},
+            {"column_name": "age", "column_type": "Number", "column_id": "age"},
+            {"column_name": "tags", "column_type": "Array", "column_id": "tags", "array_type": "String", "default_value": []},
+            {"column_name": "status", "column_type": "Enum", "column_id": "status", "enum_options": ["active", "inactive"], "default_value": "active"},
+        ],
+    }
+
+    res = client.tables.create_table(PROJECT_ID, spec)
+    print(json.dumps(res, indent=2))
+
+    assert isinstance(res, dict)

wexa_sdk-0.1.7/tests/test_tables_create_rich.py

@@ -0,0 +1,54 @@
+from wexa_sdk import WexaClient
+
+
+def test_create_table_rich_spec(monkeypatch):
+    c = WexaClient(base_url="https://api.wexa.ai", api_key="key")
+    calls = []
+
+    def fake_request(method, path, *, params=None, json=None, headers=None):  # type: ignore
+        calls.append((method, path, params, json))
+        return {"ok": True}
+
+    c.http.request = fake_request  # type: ignore
+
+    spec = {
+        "table_name": "Customers",
+        "columns": [
+            {"column_name": "email", "column_type": "String", "column_id": "email"},
+            {
+                "column_name": "tags",
+                "column_type": "Array",
+                "column_id": "tags",
+                "array_type": "String",
+                "default_value": [],
+            },
+            {
+                "column_name": "status",
+                "column_type": "Enum",
+                "column_id": "status",
+                "enum_options": ["active", "inactive"],
+                "default_value": "active",
+            },
+            {
+                "column_name": "profile",
+                "column_type": "Object",
+                "column_id": "profile",
+                "object_fields": [{"key": "firstName", "keyType": "String"}],
+            },
+        ],
+        "triggers": [
+            {"goal": "audit new row", "event": "row_created", "trigger_type": "coworker"}
+        ],
+    }
+
+    project_id = "proj123"
+    c.tables.create_table(project_id, spec)
+
+    # Assertions
+    assert calls[0][0] == "POST"
+    assert calls[0][1] == "/create/table"
+    assert calls[0][2] == {"projectID": project_id}
+    body = calls[0][3]
+    assert body["projectID"] == project_id
+    assert body["table_name"] == "Customers"
+    assert isinstance(body.get("columns"), list)

{wexa_sdk-0.1.3 → wexa_sdk-0.1.7}/wexa_sdk/agentflows.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import Optional, TypedDict
 from .core.http import HttpClient
 
@@ -73,3 +74,49 @@ class AgentFlows:
 
     def update(self, id: str, body: dict):
         return self.http.request("PUT", f"/agentflow/{id}", json=body)
+
+    # 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-0.1.3 → wexa_sdk-0.1.7}/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-0.1.3 → wexa_sdk-0.1.7}/wexa_sdk/core/http.py

@@ -37,7 +37,7 @@ class HttpClient:
         hdrs = {
             "content-type": "application/json",
             "x-api-key": self.api_key,
-            "X-Wexa-SDK-Version": "py/0.1.0",
+            "X-Wexa-SDK-Version": "py/0.1.7",
         }
         if self.user_agent:
             hdrs["User-Agent"] = self.user_agent

{wexa_sdk-0.1.3 → wexa_sdk-0.1.7}/wexa_sdk/projects.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 from typing import Optional, Dict, Any, TypedDict
+from urllib.parse import quote
 
 from .core.http import HttpClient
 
@@ -29,7 +30,9 @@ class Projects:
     # Per developers.wexa.ai: POST https://api.wexa.ai/v1/project
     def create(self, body: ProjectCreateBody):
         """
-        Expected body (example):
+        Create a project with a request body.
+
+        Example body:
         {
           "orgId": "67fdea40aac77be632954f0f",
           "projectName": "New",
@@ -49,10 +52,7 @@ class Projects:
         coworker_role: Optional[str] = None,
         status: Optional[str] = None,
     ):
-        """Convenience wrapper with explicit kwargs for IDE hints.
-
-        Builds the request body and calls create().
-        """
+        """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
@@ -132,3 +132,12 @@ class Projects:
 
     def delete(self, project_id: str):
         return self.http.request("DELETE", f"/v1/project/{project_id}")
+
+    def get_by_project_name(self, project_name: str):
+        """
+        Get project by projectName.
+
+        GET /project/projectName/{projectName}
+        """
+        safe = quote(project_name, safe="")
+        return self.http.request("GET", f"/project/projectName/{safe}")

{wexa_sdk-0.1.3 → wexa_sdk-0.1.7}/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.3 → wexa_sdk-0.1.7}/wexa_sdk.egg-info/PKG-INFO

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

{wexa_sdk-0.1.3 → wexa_sdk-0.1.7}/wexa_sdk.egg-info/SOURCES.txt

@@ -1,8 +1,13 @@
 README.md
 pyproject.toml
 tests/test_agentflows.py
+tests/test_agentflows_add_skilled_agent.py
 tests/test_agentflows_crud.py
+tests/test_agentflows_update_skilled_live.py
+tests/test_agentflows_update_skilled_unit.py
 tests/test_analytics.py
+tests/test_connectors_config.py
+tests/test_connectors_config_live.py
 tests/test_connectors_core.py
 tests/test_connectors_mgmt.py
 tests/test_demo_coworker_workflow.py
@@ -14,11 +19,18 @@ tests/test_integration_marketplace.py
 tests/test_marketplace.py
 tests/test_project_members.py
 tests/test_projects.py
+tests/test_projects_create.py
+tests/test_projects_create_live.py
 tests/test_projects_crud.py
 tests/test_projects_get_all.py
+tests/test_projects_get_all_live.py
+tests/test_projects_mcpconnectortesting.py
+tests/test_projects_mcpconnectortesting_live.py
 tests/test_settings.py
 tests/test_skills.py
 tests/test_tables.py
+tests/test_tables_create_live.py
+tests/test_tables_create_rich.py
 tests/test_tasks.py
 wexa_sdk/__init__.py
 wexa_sdk/agentflows.py