wexa-sdk 0.1.3__tar.gz

wexa_sdk-0.1.3/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: wexa-sdk
+Version: 0.1.3
+Summary: Official Wexa Python SDK
+Author: Wexa
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/wexa-ai/wexa-sdk
+Keywords: wexa,sdk,api
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.6
+
+# wexa-sdk (Python)
+
+Python SDK for Wexa API.
+
+```python
+from wexa_sdk import WexaClient
+```

wexa_sdk-0.1.3/README.md

@@ -0,0 +1,7 @@
+# wexa-sdk (Python)
+
+Python SDK for Wexa API.
+
+```python
+from wexa_sdk import WexaClient
+```

wexa_sdk-0.1.3/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wexa-sdk"
+version = "0.1.3"
+description = "Official Wexa Python SDK"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "Apache-2.0" }
+keywords = ["wexa", "sdk", "api"]
+authors = [{ name = "Wexa" }]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: Apache Software License",
+  "Programming Language :: Python :: 3 :: Only",
+]
+dependencies = [
+  "httpx>=0.27",
+  "pydantic>=2.6",
+]
+
+[project.urls]
+Homepage = "https://github.com/wexa-ai/wexa-sdk"
+
+[tool.setuptools]
+packages = ["wexa_sdk", "wexa_sdk.core", "wexa_sdk.connectors", "wexa_sdk.models"]
+include-package-data = true

wexa_sdk-0.1.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

wexa_sdk-0.1.3/tests/test_agentflows.py

@@ -0,0 +1,22 @@
+import pytest
+from wexa_sdk import WexaClient
+
+
+def test_agentflows_list_builds_params(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["method"] = method
+        calls["path"] = path
+        calls["params"] = params
+        return {"ok": True}
+
+    c.http.request = fake_request  # type: ignore
+
+    res = c.agentflows.list(projectID="p1", skip=1, limit=2)
+
+    assert calls["method"] == "GET"
+    assert calls["path"] == "/agentflows"
+    assert calls["params"] == {"projectID": "p1", "skip": 1, "limit": 2}
+    assert res == {"ok": True}

wexa_sdk-0.1.3/tests/test_agentflows_crud.py

@@ -0,0 +1,23 @@
+from wexa_sdk import WexaClient
+
+
+def test_agentflows_crud(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
+
+    # create with projectID in body -> should go to query as well
+    c.agentflows.create({"name": "N", "projectID": "p1"})
+    # update
+    c.agentflows.update("af1", {"name": "U"})
+    # delete
+    c.agentflows.delete("p1", "af1")
+
+    assert calls[0][0] == "POST" and calls[0][1] == "/agentflow/" and calls[0][2] == {"projectID": "p1"}
+    assert calls[1][0] == "PUT" and calls[1][1] == "/agentflow/af1"
+    assert calls[2][0] == "DELETE" and calls[2][1] == "/agentflow/p1/af1"

wexa_sdk-0.1.3/tests/test_analytics.py

@@ -0,0 +1,21 @@
+from wexa_sdk import WexaClient
+
+
+def test_analytics_get_builds_query(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["method"] = method
+        calls["path"] = path
+        calls["params"] = params
+        return {"ok": True}
+
+    c.http.request = fake_request  # type: ignore
+
+    res = c.analytics.get("p1")
+
+    assert calls["method"] == "GET"
+    assert calls["path"] == "/analytics"
+    assert calls["params"] == {"projectID": "p1"}
+    assert res == {"ok": True}

wexa_sdk-0.1.3/tests/test_connectors_core.py

@@ -0,0 +1,45 @@
+from wexa_sdk import WexaClient
+
+
+def test_connectors_core_actions_and_config(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
+
+    # action without connector_id, then with connector_id
+    c.connectors.action("drive", "sync", body={"x": 1}, projectID="p1")
+    c.connectors.action("drive", "sync", "cid1", body={"y": 2}, projectID="p1")
+
+    # config
+    c.connectors.set_config("drive", "p1", {"cfg": True})
+    c.connectors.get_config("drive", "p1")
+
+    assert calls[0] == (
+        "POST",
+        "/actions/drive/sync",
+        {"projectID": "p1"},
+        {"x": 1},
+    )
+    assert calls[1] == (
+        "POST",
+        "/actions/drive/sync/cid1",
+        {"projectID": "p1"},
+        {"y": 2},
+    )
+    assert calls[2] == (
+        "POST",
+        "/actions/drive/config",
+        {"projectID": "p1"},
+        {"cfg": True},
+    )
+    assert calls[3] == (
+        "GET",
+        "/actions/drive/config/p1",
+        None,
+        None,
+    )

wexa_sdk-0.1.3/tests/test_connectors_mgmt.py

@@ -0,0 +1,44 @@
+from wexa_sdk import WexaClient
+
+
+def test_connectors_mgmt_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
+
+    # list variants
+    c.connectors_mgmt.list()
+    c.connectors_mgmt.list("p1")
+    c.connectors_mgmt.list_by_project_id("p1")
+
+    # get
+    c.connectors_mgmt.get_by_id("cid1")
+    c.connectors_mgmt.get_by_id_path("cid1")
+
+    # delete variants
+    c.connectors_mgmt.delete("cid1")
+    c.connectors_mgmt.delete("cid1", project_id="p1")
+    c.connectors_mgmt.delete_by_id_path("cid1", project_id="p1")
+
+    # status + triggers
+    c.connectors_mgmt.update_status(new_status="active", connectorID="cid1", data_loader_config={})
+    c.connectors_mgmt.list_trigger_actions("p1")
+    c.connectors_mgmt.list_trigger_actions_by_project("p1")
+
+    i = 0
+    assert calls[i] == ("GET", "/connectors/", None, None); i += 1
+    assert calls[i] == ("GET", "/connectors/", {"projectID": "p1"}, None); i += 1
+    assert calls[i] == ("GET", "/connectors/p1", None, None); i += 1
+    assert calls[i] == ("GET", "/v1/connector/cid1", None, None); i += 1
+    assert calls[i] == ("GET", "/connector/cid1", None, None); i += 1
+    assert calls[i] == ("DELETE", "/v1/connector/cid1", None, None); i += 1
+    assert calls[i] == ("DELETE", "/v1/connector/cid1", {"projectID": "p1"}, None); i += 1
+    assert calls[i] == ("DELETE", "/connector/cid1", {"projectID": "p1"}, None); i += 1
+    assert calls[i] == ("POST", "/connectors/change_status", None, {"new_status": "active", "connectorID": "cid1", "data_loader_config": {}}); i += 1
+    assert calls[i] == ("GET", "/connectors/trigger_actions", {"projectID": "p1"}, None); i += 1
+    assert calls[i] == ("GET", "/connectors/p1/trigger_actions", {"projectID": "p1"}, None); i += 1

wexa_sdk-0.1.3/tests/test_demo_coworker_workflow.py

@@ -0,0 +1,68 @@
+import os
+import time
+import json
+import pytest
+
+from wexa_sdk import WexaClient
+
+BASE = os.environ.get("WEXA_BASE_URL", "https://api.wexa.ai")
+API_KEY = os.environ.get("WEXA_API_KEY")
+PROJECT_ID = os.environ.get("WEXA_PROJECT_ID", "69088bf4121a635f1301ad8c")
+
+
+@pytest.mark.skipif(not API_KEY, reason="Set WEXA_API_KEY to run this integration test")
+def test_coworker_create_or_load_and_execute():
+    c = WexaClient(base_url=BASE, api_key=API_KEY)
+    # Use a mostly-unique name per run to avoid conflicts
+    name = f"InvoiceProcessor-{int(time.time()) % 100000}"
+
+    def get_by_name(name: str, project_id: str):
+        skip, limit = 0, 100
+        while True:
+            # Some environments reject skip=0; omit skip on first page
+            if skip > 0:
+                page = c.agentflows.list(projectID=project_id, skip=skip, limit=limit) or {}
+            else:
+                page = c.agentflows.list(projectID=project_id, limit=limit) or {}
+            arr = page.get("agentflows") or page.get("data") or []
+            for af in arr:
+                if af.get("name") == name:
+                    return af
+            if len(arr) < limit:
+                return None
+            skip += limit
+
+    af = get_by_name(name, PROJECT_ID)
+    if not af:
+        body = {
+            "name": name,
+            "description": "created via SDK test",
+            "role": "SDK_ROLE",
+            "projectID": PROJECT_ID,
+        }
+        af = c.agentflows.create(body, projectID=PROJECT_ID)
+        assert af and af.get("_id"), "Agentflow creation failed"
+
+    # Execute the flow
+    payload = {
+        "agentflow_id": af["_id"],
+        "executed_by": "sdk@test",
+        "goal": "Demo run",
+        "input_variables": {"echo": "hello"},
+        "projectID": PROJECT_ID,
+    }
+    started = c.executions.start(payload, projectID=PROJECT_ID)
+    assert started and started.get("_id"), "Execution start failed"
+
+    # Try a brief wait; if it times out, fetch current state and finish
+    try:
+        res = c.executions.wait(started["_id"], timeout_ms=15_000)
+    except Exception:
+        res = c.executions.get(started["_id"])
+
+    assert isinstance(res, dict)
+    # Print (visible in CI logs) for manual inspection if needed
+    print(json.dumps({
+        "agentflow": {"_id": af.get("_id"), "name": af.get("name")},
+        "execution": {"_id": started.get("_id"), "status": res.get("status")}
+    })[:1000])

wexa_sdk-0.1.3/tests/test_executions.py

@@ -0,0 +1,23 @@
+from wexa_sdk import WexaClient
+
+
+def test_executions_start_posts_payload_and_query(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["method"] = method
+        calls["path"] = path
+        calls["params"] = params
+        calls["json"] = json
+        return {"execution_id": "e1"}
+
+    c.http.request = fake_request  # type: ignore
+
+    res = c.executions.start({"agentflow_id": "a1", "inputs": {}}, projectID="p1")
+
+    assert calls["method"] == "POST"
+    assert calls["path"] == "/execute_flow"
+    assert calls["params"] == {"projectID": "p1"}
+    assert calls["json"] == {"agentflow_id": "a1", "inputs": {}}
+    assert res == {"execution_id": "e1"}

wexa_sdk-0.1.3/tests/test_files.py

@@ -0,0 +1,20 @@
+from wexa_sdk import WexaClient
+
+
+def test_files_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
+
+    c.files.upload_request("proj", "bucket", {"filenames": ["a.txt"]})
+    c.files.get_by_file_id("file1", "proj")
+    c.files.list_by_connector("conn1")
+
+    assert calls[0][0] == "POST" and calls[0][1] == "/files/upload" and calls[0][2] == {"projectID": "proj", "container_name": "bucket"}
+    assert calls[1][0] == "GET" and calls[1][1] == "/file/file1/" and calls[1][2] == {"projectID": "proj"}
+    assert calls[2][0] == "GET" and calls[2][1] == "/files/conn1/connector/"

wexa_sdk-0.1.3/tests/test_inbox.py

@@ -0,0 +1,28 @@
+from wexa_sdk import WexaClient
+
+
+def test_inbox_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
+
+    c.inbox.create({"x": 1})
+    c.inbox.list("p1", limit=2)
+    c.inbox.update_runtime("p1", {"a": 1})
+    c.inbox.update_anomaly("p1", {"b": 2})
+    c.inbox.update_preview("p1", {"c": 3})
+    c.inbox.update_preview_by_execution("exec1", {"d": 4}, "p1")
+    c.inbox.get("inb1", "p1")
+
+    assert calls[0] == ("POST", "/inbox/create", None, {"x": 1})
+    assert calls[1] == ("GET", "/inbox", {"projectID": "p1", "limit": 2}, None)
+    assert calls[2] == ("POST", "/inbox/update/runtime_input/", {"projectID": "p1"}, {"a": 1})
+    assert calls[3] == ("POST", "/inbox/update/anomaly_detection/", {"projectID": "p1"}, {"b": 2})
+    assert calls[4] == ("POST", "/inbox/update/preview/", {"projectID": "p1"}, {"c": 3})
+    assert calls[5] == ("POST", "/inbox/update/preview/exec1", {"projectID": "p1"}, {"d": 4})
+    assert calls[6] == ("GET", "/inbox/inb1", {"projectID": "p1"}, None)

wexa_sdk-0.1.3/tests/test_integration_agentflows_create.py

@@ -0,0 +1,40 @@
+import os, time, json, pytest
+from wexa_sdk import WexaClient
+from wexa_sdk.core.http import ApiError
+
+missing_env = not (os.getenv("WEXA_BASE_URL") and os.getenv("WEXA_API_KEY") and os.getenv("PROJECT_ID"))
+
+@pytest.mark.integration
+@pytest.mark.skipif(missing_env, reason="WEXA_BASE_URL/WEXA_API_KEY/PROJECT_ID not set")
+def test_agentflows_create_get_delete():
+    base = os.environ["WEXA_BASE_URL"]
+    key = os.environ["WEXA_API_KEY"]
+    pid = os.environ["PROJECT_ID"]
+
+    c = WexaClient(base_url=base, api_key=key)
+
+    body = {
+        "name": f"sdk-integ-py-{int(time.time())}",
+        "description": "integration-create via sdk",
+        "role": "SDK_ROLE",
+        "projectID": pid,
+    }
+
+    afid = None
+    try:
+        created = c.agentflows.create(body, projectID=pid)
+        assert isinstance(created, dict)
+        afid = created.get("_id") or created.get("id")
+        assert afid and isinstance(afid, str)
+
+        got = c.agentflows.get(afid)
+        assert got.get("_id") == afid
+        assert got.get("name") == body["name"]
+    except ApiError as e:
+        pytest.fail(f"API error: {e.status} {e.detail}")
+    finally:
+        if afid:
+            try:
+                c.agentflows.delete(pid, afid)
+            except ApiError:
+                pass

wexa_sdk-0.1.3/tests/test_integration_marketplace.py

@@ -0,0 +1,13 @@
+import os
+import pytest
+from wexa_sdk import WexaClient
+
+pytestmark = pytest.mark.integration
+
+missing_env = not os.getenv("WEXA_BASE_URL") or not os.getenv("WEXA_API_KEY")
+
+@pytest.mark.skipif(missing_env, reason="WEXA_BASE_URL/WEXA_API_KEY not set")
+def test_marketplace_lists_coworkers():
+    c = WexaClient(base_url=os.environ["WEXA_BASE_URL"], api_key=os.environ["WEXA_API_KEY"])
+    res = c.marketplace.list_coworkers(search_key="", limit=1)
+    assert isinstance(res, dict)

wexa_sdk-0.1.3/tests/test_marketplace.py

@@ -0,0 +1,24 @@
+from wexa_sdk import WexaClient
+
+
+def test_marketplace_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
+
+    c.marketplace.list_connectors(search_key="", projectID="p1", filter_type="ALL")
+    c.marketplace.list_coworkers(search_key="", limit=2)
+    c.marketplace.get_coworker_by_id("cw1")
+    c.marketplace.purchase_coworker("cw1", organization_id="org1", body={"plan": "pro"})
+    c.marketplace.check_coworker_update("cw1")
+
+    assert calls[0] == ("GET", "/public/connectors/all", {"search_key": "", "projectID": "p1", "filter_type": "ALL"}, None)
+    assert calls[1] == ("GET", "/public/marketplace/coworkers", {"search_key": "", "limit": 2}, None)
+    assert calls[2] == ("GET", "/public/marketplace/coworker/cw1", None, None)
+    assert calls[3] == ("POST", "/marketplace/coworker/cw1/purchase", {"organization_id": "org1"}, {"plan": "pro"})
+    assert calls[4] == ("GET", "/marketplace/coworker/update/cw1/check", None, None)

wexa_sdk-0.1.3/tests/test_project_members.py

@@ -0,0 +1,18 @@
+from wexa_sdk import WexaClient
+
+
+def test_project_members_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
+
+    c.project_members.summary("p1")
+    c.project_members.list("p1")
+
+    assert calls[0] == ("GET", "/project-member/p1/summary", None, None)
+    assert calls[1] == ("GET", "/project-member/p1", None, None)

wexa_sdk-0.1.3/tests/test_projects.py

@@ -0,0 +1,22 @@
+from wexa_sdk import WexaClient
+
+
+def test_projects_create_posts_body(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["method"] = method
+        calls["path"] = path
+        calls["json"] = json
+        return {"_id": "p1"}
+
+    c.http.request = fake_request  # type: ignore
+
+    body = {"orgId": "o1", "projectName": "Test", "description": "d", "coworker_role": "r"}
+    res = c.projects.create(body)
+
+    assert calls["method"] == "POST"
+    assert calls["path"] == "/v1/project"
+    assert calls["json"] == body
+    assert res == {"_id": "p1"}

wexa_sdk-0.1.3/tests/test_projects_crud.py

@@ -0,0 +1,24 @@
+from wexa_sdk import WexaClient
+
+
+def test_projects_crud_paths(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
+
+    c.projects.create({"orgId": "o1", "projectName": "P"})
+    c.projects.list()
+    c.projects.get("p1")
+    c.projects.update("p1", {"description": "d"})
+    c.projects.delete("p1")
+
+    assert calls[0][0] == "POST" and calls[0][1] == "/v1/project"
+    assert calls[1][0] == "GET" and calls[1][1] == "/v1/project"
+    assert calls[2][0] == "GET" and calls[2][1] == "/v1/project/p1"
+    assert calls[3][0] == "PUT" and calls[3][1] == "/v1/project/p1"
+    assert calls[4][0] == "DELETE" and calls[4][1] == "/v1/project/p1"

wexa_sdk-0.1.3/tests/test_projects_get_all.py

@@ -0,0 +1,42 @@
+import os
+from wexa_sdk import WexaClient
+
+
+def test_projects_get_all_path_and_params(monkeypatch):
+    base_url = os.getenv("WEXA_BASE_URL", "https://api.wexa.ai")
+    api_key = os.getenv("WEXA_API_KEY", "key")
+
+    c = WexaClient(base_url=base_url, api_key=api_key)
+    calls = []
+
+    def fake_request(method, path, *, params=None, json=None, headers=None):  # type: ignore
+        calls.append((method, path, params, json))
+        # Simulate API shape
+        return {"items": [], "count": 0}
+
+    # Patch HTTP layer to avoid real network
+    c.http.request = fake_request  # type: ignore
+
+    res = c.projects.get_all(
+        status="published",
+        user_id="66f3cdde22bc63eb7490e23c",
+        org_id="66f3cdde22bc63eb7490e23e",
+        page=1,
+        limit=12,
+    )
+
+    # Assert method and path
+    assert calls[0][0] == "GET"
+    assert calls[0][1] == "/v1/project"  # versioned path
+
+    # Assert query params
+    assert calls[0][2] == {
+        "status": "published",
+        "userId": "66f3cdde22bc63eb7490e23c",
+        "orgId": "66f3cdde22bc63eb7490e23e",
+        "page": 1,
+        "limit": 12,
+    }
+
+    # Assert returned structure from our fake
+    assert res == {"items": [], "count": 0}

wexa_sdk-0.1.3/tests/test_settings.py

@@ -0,0 +1,19 @@
+from wexa_sdk import WexaClient
+
+
+def test_settings_get(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["method"] = method
+        calls["path"] = path
+        return {"ok": True}
+
+    c.http.request = fake_request  # type: ignore
+
+    res = c.settings.get("p1")
+
+    assert calls["method"] == "GET"
+    assert calls["path"] == "/settings/p1"
+    assert res == {"ok": True}

wexa_sdk-0.1.3/tests/test_skills.py

@@ -0,0 +1,24 @@
+from wexa_sdk import WexaClient
+
+
+def test_skills_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
+
+    c.skills.create({"name": "s1"})
+    c.skills.list("p1", limit=2)
+    c.skills.list_by_category("p1", "LLM", limit=1)
+    c.skills.get_by_id("sid1")
+    c.skills.get_by_name("s1", "p1")
+
+    assert calls[0] == ("POST", "/skills/", None, {"name": "s1"})
+    assert calls[1] == ("GET", "/skills/", {"projectID": "p1", "limit": 2}, None)
+    assert calls[2] == ("GET", "/skills/category", {"projectId": "p1", "category": "LLM", "limit": 1}, None)
+    assert calls[3] == ("GET", "/skills/sid1", None, None)
+    assert calls[4] == ("GET", "/skills/", {"name": "s1", "projectID": "p1"}, None)