actionlayer 0.7.0__py3-none-any.whl

actionlayer-0.7.0.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: actionlayer
+Version: 0.7.0
+Summary: MCP server for ActionLayer — give Claude Code and other MCP hosts access to ActionLayer's browser-action catalog with per-session credential intake.
+Project-URL: Homepage, https://actionlayer.io
+Project-URL: Repository, https://github.com/grimjjow/actionlayer
+Author: ActionLayer
+License: MIT
+Keywords: actionlayer,agents,claude,claude-code,mcp,tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: fastmcp>=0.4.0
+Requires-Dist: httpx>=0.27.0
+Description-Content-Type: text/markdown
+
+# actionlayer
+
+<!-- mcp-name: io.actionlayer/actionlayer -->
+
+MCP server for [ActionLayer](https://actionlayer.io) — let Claude Code (and any MCP host) drive browser-based sites on your behalf.
+
+> Previously published as `actionlayer-mcp`. That project is no longer
+> maintained and stopped at 0.6.0 — install `actionlayer` instead.
+
+## Install
+
+Get an API key from your ActionLayer dashboard at https://actionlayer.io, then:
+
+```bash
+claude mcp add --scope user actionlayer "uvx" "actionlayer" \
+  --env ACTIONLAYER_API_KEY="ak_…" \
+  --env ACTIONLAYER_API_URL="https://api.actionlayer.io"
+```
+
+Restart Claude Code and ask it to do something for you.
+
+## Usage from other MCP hosts
+
+```bash
+actionlayer
+```
+
+Works with Cursor, Cody, Codex, etc.
+
+Env vars:
+- `ACTIONLAYER_API_KEY` — required
+- `ACTIONLAYER_API_URL` — defaults to `https://api.actionlayer.io`
+
+## Changelog
+
+### 0.7.0
+
+Renamed: published as `actionlayer` on PyPI from this release on
+(`actionlayer-mcp` is orphaned and frozen at 0.6.0). No code changes.
+The command is now `actionlayer`; `actionlayer-mcp` remains as an
+alias. Includes everything from the unreleased 0.6.1.
+
+### 0.6.1
+
+No code changes. Embeds the MCP Registry `mcp-name` ownership token
+so the package can be listed at registry.modelcontextprotocol.io.
+
+### 0.4.2
+
+Internal taxonomy scrub. No behavior change; tool descriptions and
+`next_action.prompt` fallbacks rephrased so calling agents don't
+surface ActionLayer's internal terminology in their own user-facing
+text.
+
+### 0.4.1
+
+Payment-card approval flow (Phase 2 of the agent payments plan).
+
+- `actionlayer_reply` now accepts `payment_approved: bool` for
+  tickets whose info_request includes `payment_status`. Users
+  approve a charge against their card-on-file with one call.
+- `actionlayer_get_task` / `actionlayer_next_action` surface
+  `card_brand`, `card_last4`, `amount_usd`, and `payment_status`
+  on the info_request payload so an agent can prompt the user
+  with "Approve $X.XX charge on your <brand> card ending <last4>?"
+- The card PAN itself NEVER crosses the MCP boundary. The charge
+  is completed against the user's card on file; the PAN never
+  appears on agent-visible surfaces. This is by design per
+  `docs/agent_payments_plan.md`.
+
+### 0.4.0
+
+**Backwards-incompatible — public API taxonomy changed.**
+
+- Ticket `state` collapses the in-flight phases into a single
+  public value `pending`. Polling code that branched on the
+  individual sub-phases (e.g. `if state == "executing"`) must
+  switch to `state == "pending"`. Terminal states (`completed`,
+  `failed`, `cancelled`) and `blocked_on_user` are unchanged.
+- `live_view_url` is no longer returned by the public tools
+  (`actionlayer_invoke_action`, `actionlayer_get_action_ticket`).
+  User-facing callers should drive the task via polling
+  `actionlayer_get_action_ticket` and responding to
+  `blocked_on_user` prompts.
+- `actionlayer_invoke_action` sync response now uses
+  `outcome="queued"` (instead of `outcome="blocked"`) when the
+  task is taking longer than the sync window allows. Callers
+  handling `outcome` need to add a `queued` branch: poll
+  `actionlayer_get_action_ticket` for terminal state.
+- Terminal tickets now carry a free-text `reason` field summarising
+  the outcome (derived from `result.summary` on completed, `error`
+  on failed). Pre-existing `result` / `error` fields preserved
+  for callers that want the raw structured payload.
+
+### 0.3.1
+- Update default API URL to `https://api.actionlayer.io`
+  (`api.action-layer.dev` still redirects, but the new host is the
+  current canonical name).
+
+### 0.3.0
+- Browser-only catalog. Per-session credential intake.
+
+### 0.2.0
+- Async-by-default dispatch for browser actions + ticket polling tool.
+
+### 0.1.0
+- Initial release.
+
+## License
+
+MIT

actionlayer-0.7.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+actionlayer_mcp/__init__.py,sha256=zqVf1Ww5J2y73Ni2aoOYywLAwmsK_7mRfnZx-U2XYaA,625
+actionlayer_mcp/client.py,sha256=R81e89aq0-xWZcH_bYAUhk0M7sllyU3naQ4E-MbWGqg,11662
+actionlayer_mcp/server.py,sha256=xKmUsy9XjhURknS2mxvPD7wYxbdfd6mWrbOTvVWD2Ws,46130
+actionlayer-0.7.0.dist-info/METADATA,sha256=p7I_ymyxk0DBCnCxk99mafANHLpdcxCemmqkWQ_xhmA,4728
+actionlayer-0.7.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+actionlayer-0.7.0.dist-info/entry_points.txt,sha256=Y8QmcYfYbimW9Um0yhcnL4u0MjQiKSeICPHsOo_i4F8,106
+actionlayer-0.7.0.dist-info/RECORD,,

actionlayer-0.7.0.dist-info/WHEEL

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

actionlayer-0.7.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+actionlayer = actionlayer_mcp.server:main
+actionlayer-mcp = actionlayer_mcp.server:main

actionlayer_mcp/__init__.py

@@ -0,0 +1,18 @@
+"""ActionLayer MCP server.
+
+A thin Model Context Protocol shim that translates MCP tool calls into
+ActionLayer REST API calls. Runs on the user's machine (or wherever
+their agent host runs); reads ACTIONLAYER_API_KEY + ACTIONLAYER_API_URL
+from the environment.
+
+Distributed via PyPI as `actionlayer` (formerly `actionlayer-mcp`,
+orphaned at 0.6.0). The console_scripts entry point lets agent hosts
+run it as `uvx actionlayer` or `pipx run actionlayer` with no clone
+needed.
+"""
+
+from actionlayer_mcp.client import ActionLayerClient, ApiError
+
+__version__ = "0.7.0"
+
+__all__ = ["ActionLayerClient", "ApiError", "__version__"]

actionlayer_mcp/client.py

@@ -0,0 +1,317 @@
+"""HTTP client wrapping the ActionLayer REST API.
+
+A small async wrapper kept separate from server.py so it's reusable
+(future SDK can import it). All network IO lives here; server.py is
+pure protocol translation.
+
+Auth: bearer token from ACTIONLAYER_API_KEY env var. Errors are mapped
+to ApiError with the upstream status + JSON detail string when present.
+"""
+
+from __future__ import annotations
+
+import os
+import uuid
+from typing import Any, Optional
+
+import httpx
+
+DEFAULT_API_URL = "https://api.actionlayer.io"
+USER_AGENT = "actionlayer-mcp/0.7.0"
+DEFAULT_TIMEOUT = httpx.Timeout(connect=5.0, read=30.0, write=10.0, pool=5.0)
+
+
+class ApiError(RuntimeError):
+    """Raised when the ActionLayer API returns a non-2xx response."""
+
+    def __init__(self, status: int, detail: str):
+        super().__init__(f"ActionLayer API {status}: {detail}")
+        self.status = status
+        self.detail = detail
+
+
+class ActionLayerClient:
+    """Thin async wrapper. One instance per MCP server lifetime."""
+
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str] = None,
+        api_url: Optional[str] = None,
+    ):
+        self.api_key = api_key or os.environ.get("ACTIONLAYER_API_KEY", "")
+        self.api_url = (
+            api_url
+            or os.environ.get("ACTIONLAYER_API_URL")
+            or DEFAULT_API_URL
+        ).rstrip("/")
+        if not self.api_key:
+            raise RuntimeError(
+                "ACTIONLAYER_API_KEY env var not set. Run "
+                "`actionlayer configure --api-key ak_...` to set it up."
+            )
+        self._client = httpx.AsyncClient(
+            base_url=self.api_url,
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "User-Agent": USER_AGENT,
+            },
+            timeout=DEFAULT_TIMEOUT,
+        )
+
+    async def aclose(self) -> None:
+        await self._client.aclose()
+
+    # --- Tasks --------------------------------------------------------
+
+    async def start_task(
+        self,
+        *,
+        goal: str,
+        max_budget_usd: Optional[float] = None,
+        webhook_url: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+        target_url: Optional[str] = None,
+        credentials_source: Optional[str] = None,
+    ) -> dict[str, Any]:
+        # An auto-generated idempotency key gives the API a stable replay
+        # surface, but each call still gets a fresh ticket — true
+        # deduplication requires the agent to pass its own key, which is
+        # the right design (only the agent knows whether two same-arg
+        # calls are "retry" or "do it again").
+        # Same `al-` prefix as the SDK so a retry that crosses the
+        # SDK<->MCP shim boundary still de-dupes on the server side.
+        # SEC-MCP-010.
+        key = idempotency_key or f"al-{uuid.uuid4()}"
+        body: dict[str, Any] = {"goal": goal}
+        if max_budget_usd is not None:
+            body["max_budget_usd"] = max_budget_usd
+        if webhook_url is not None:
+            body["webhook_url"] = webhook_url
+        if target_url is not None:
+            body["target_url"] = target_url
+        if credentials_source is not None:
+            body["credentials_source"] = credentials_source
+        return await self._post("/tasks", json=body, headers={"Idempotency-Key": key})
+
+    async def get_task(self, ticket_id: str) -> dict[str, Any]:
+        return await self._get(f"/tasks/{ticket_id}")
+
+    async def reply_task(
+        self,
+        ticket_id: str,
+        *,
+        message: Optional[str] = None,
+        field: Optional[str] = None,
+        value: Optional[str] = None,
+        sensitive: bool = False,
+        info: Optional[dict[str, Any]] = None,
+    ) -> dict[str, Any]:
+        """Forward a reply to /tasks/{id}/reply.
+
+        `info` is the info-required payload — pass-through to the
+        `info` field on ReplyTaskRequest. Required when the ticket
+        carries an `info_request` (set when ActionLayer paused to collect info from the user);
+        the API 422s otherwise.
+        """
+        body: dict[str, Any] = {"sensitive": sensitive}
+        if message is not None:
+            body["message"] = message
+        if field is not None:
+            body["field"] = field
+        if value is not None:
+            body["value"] = value
+        if info is not None:
+            body["info"] = info
+        return await self._post(f"/tasks/{ticket_id}/reply", json=body)
+
+    async def cancel_task(self, ticket_id: str) -> dict[str, Any]:
+        return await self._post(f"/tasks/{ticket_id}/cancel", json=None)
+
+    async def submit_feedback(
+        self,
+        ticket_id: str,
+        *,
+        rating: str,
+        comment: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """Leave feedback on a finished task. `rating` is "good"/"bad";
+        `comment` is an optional note. The API 409s unless the ticket is
+        completed or failed."""
+        body: dict[str, Any] = {"rating": rating}
+        if comment is not None:
+            body["comment"] = comment
+        return await self._post(f"/tasks/{ticket_id}/feedback", json=body)
+
+    # --- Skills -------------------------------------------------------
+
+    async def list_skills(
+        self, *, source_format: Optional[str] = None
+    ) -> list[dict[str, Any]]:
+        params: dict[str, Any] = {}
+        if source_format:
+            params["source_format"] = source_format
+        result = await self._get("/skills", params=params)
+        # /skills returns either a bare list or {"items": [...]} —
+        # accept either to stay forward-compatible.
+        if isinstance(result, dict) and "items" in result:
+            return result["items"]
+        return result  # type: ignore[return-value]
+
+    # --- Actions (P10) ------------------------------------------------
+
+    async def list_actions(
+        self,
+        *,
+        provider: Optional[str] = None,
+        category: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """GET /v1/actions — returns the full catalog response shape
+        ({count, actions, providers, categories}). The MCP server
+        decides what subset to surface to the agent host."""
+        params: dict[str, Any] = {}
+        if provider:
+            params["provider"] = provider
+        if category:
+            params["category"] = category
+        return await self._get("/v1/actions", params=params)
+
+    async def get_action(self, action_id: str) -> dict[str, Any]:
+        """GET /v1/actions/{id} — full ActionDefinition with the
+        input/output schemas."""
+        return await self._get(f"/v1/actions/{action_id}")
+
+    async def invoke_action(
+        self,
+        action_id: str,
+        *,
+        inputs: dict[str, Any],
+        executor: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """POST /v1/actions/{id}.
+
+        Two response shapes depending on the action's executor:
+          * API actions (gmail, slack, github, ...): run sync. Outcome
+            is one of 'succeeded' | 'blocked' | 'failed' with the
+            output inline.
+          * Browser actions (resy, partiful, usps, ...): return 202
+            with outcome='queued' + payload.ticket_id + payload.poll_path.
+            Caller polls get_action_ticket(ticket_id) until is_terminal.
+
+        Same shape either way (ActionInvokeResponse). Caller branches
+        on outcome to decide whether to poll.
+        """
+        body: dict[str, Any] = {"inputs": inputs}
+        if executor:
+            body["executor"] = executor
+        return await self._post(f"/v1/actions/{action_id}", json=body)
+
+    async def get_action_ticket(self, ticket_id: str) -> dict[str, Any]:
+        """GET /v1/actions/tickets/{id} — poll an async action ticket.
+
+        Returns ActionTicketResponse: state, outcome, output, error,
+        reason, blocked_reason, is_terminal, creds_prompt. Poll every
+        3-5s until is_terminal=True. When creds_prompt is set the
+        ticket is waiting for the user to submit credentials via
+        provide_credentials.
+        """
+        return await self._get(f"/v1/actions/tickets/{ticket_id}")
+
+    async def provide_credentials(
+        self,
+        ticket_id: str,
+        *,
+        fields: dict[str, str],
+        remember_for_session: bool = False,
+    ) -> dict[str, Any]:
+        """POST /v1/actions/tickets/{id}/credentials — submit creds
+        for a ticket blocked with creds_required.
+
+        Credentials are KMS-encrypted in transit + at rest in Redis
+        with a 15-minute TTL (single-use GETDEL by the worker). Never
+        written to Postgres or logs.
+        """
+        body: dict[str, Any] = {"fields": fields}
+        if remember_for_session:
+            body["remember_for_session"] = True
+        return await self._post(
+            f"/v1/actions/tickets/{ticket_id}/credentials", json=body
+        )
+
+    # --- Jobs (P6) ----------------------------------------------------
+
+    async def create_job(
+        self,
+        *,
+        goal: str,
+        budget_usd: Optional[float] = None,
+        deadline: Optional[str] = None,
+        webhook_url: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """POST /v1/jobs — kick off a multi-step planner-driven job.
+
+        `deadline` is ISO 8601 (e.g. '2026-05-15T19:00:00-07:00').
+        Returns the job in 'planning' state; caller polls get_job.
+        """
+        body: dict[str, Any] = {"goal": goal}
+        if budget_usd is not None:
+            body["budget_usd"] = budget_usd
+        if deadline is not None:
+            body["deadline"] = deadline
+        if webhook_url is not None:
+            body["webhook_url"] = webhook_url
+        return await self._post("/v1/jobs", json=body)
+
+    async def get_job(self, job_id: str) -> dict[str, Any]:
+        """GET /v1/jobs/{id} — returns the full Job + items array."""
+        return await self._get(f"/v1/jobs/{job_id}")
+
+    async def cancel_job(self, job_id: str) -> dict[str, Any]:
+        return await self._post(f"/v1/jobs/{job_id}/cancel", json=None)
+
+    async def resume_job(self, job_id: str) -> dict[str, Any]:
+        return await self._post(f"/v1/jobs/{job_id}/resume", json=None)
+
+    # --- Internals ----------------------------------------------------
+
+    async def _get(
+        self, path: str, *, params: Optional[dict[str, Any]] = None
+    ) -> Any:
+        resp = await self._client.get(path, params=params)
+        return _parse(resp)
+
+    async def _post(
+        self,
+        path: str,
+        *,
+        json: Optional[dict[str, Any]],
+        headers: Optional[dict[str, str]] = None,
+    ) -> dict[str, Any]:
+        resp = await self._client.post(path, json=json, headers=headers)
+        return _parse(resp)
+
+
+def _parse(resp: httpx.Response) -> Any:
+    if resp.is_success:
+        if not resp.content:
+            return {}
+        return resp.json()
+    detail: str
+    try:
+        body = resp.json()
+        detail = body.get("detail") if isinstance(body, dict) else str(body)
+        if not isinstance(detail, str):
+            detail = str(detail)
+    except Exception:
+        detail = resp.text or resp.reason_phrase
+    # SEC-MCP-011: for non-validation 5xx responses, collapse the
+    # server-emitted detail to a generic message. Validation 4xx is
+    # preserved -- the user / agent needs the specific reason to fix
+    # the call. A future verbose 500 path that leaks DB ids / file
+    # paths / cross-tenant data no longer surfaces through the SDK
+    # exception message.
+    if 500 <= resp.status_code < 600:
+        detail = "internal error -- check the ActionLayer status page"
+    raise ApiError(resp.status_code, detail)
+
+