pushary-langgraph 0.1.0__tar.gz

pushary_langgraph-0.1.0/.gitignore

@@ -0,0 +1,86 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+node_modules/
+.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# next.js
+.next/
+out/
+build/
+dist/
+
+# python
+__pycache__/
+*.pyc
+*.egg-info/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# env
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# vercel
+.vercel
+
+# local Cursor MCP config (holds the Pushary API key)
+.cursor/mcp.json
+
+# generated at build time: Cursor plugin bundled into the agent-hooks package
+packages/agent-hooks/data/cursor-plugin/
+
+# typescript
+*.tsbuild info
+
+# turbo
+.turbo
+
+# Old Shopify extension directory (deprecated)
+shopify-theme-extension/
+*.egg-info/
+
+# Prospect/outreach data
+prospect_list.csv
+prospect_research_report.txt
+
+# Launch planning docs
+PRODUCTHUNT_LAUNCH_PLAN.md
+AI-CODING-REMODEL-PLAN.md
+
+# HyperFrames launch video (separate project)
+video-launch/
+
+# Remotion render outputs
+video/public/logos/out/
+.gstack/
+
+# local AI-agent tooling (installed skills + plugin config, machine-local)
+.agents/
+.claude/
+.cursor/rules/
+pushary-app/.agents/
+pushary-app/skills-lock.json
+
+# stray empty Expo stub at repo root (real config is pushary-app/app.config.ts)
+/app.json
+
+# Play Store listing assets (large, iterating screenshots - keep local)
+pushary-app/play-assets/

pushary_langgraph-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pushary
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pushary_langgraph-0.1.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: pushary-langgraph
+Version: 0.1.0
+Summary: Human-in-the-loop for LangGraph and LangChain: a blocking ask_human, plus a durable interrupt()/Command resume that reaches your user on their phone.
+Project-URL: Homepage, https://pushary.com
+Project-URL: Documentation, https://pushary.com/docs/agents/adapters
+Author-email: Pushary <business@pushary.com>
+License: MIT
+License-File: LICENSE
+Keywords: ai-agents,approvals,human-in-the-loop,interrupt,langchain,langgraph
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: langgraph<2,>=1.0
+Requires-Dist: pushary>=1.3.2
+Description-Content-Type: text/markdown
+
+# pushary-langgraph
+
+Human-in-the-loop for [LangGraph](https://langchain-ai.github.io/langgraph/) and
+LangChain. Ask a real human to approve, and get the answer on their phone. Two seams:
+
+- **A blocking `ask_human`** you call from inside a node.
+- **A durable `pushary_interrupt`** that parks the graph with LangGraph's native
+  `interrupt()` and resumes on a signed webhook, so a long wait holds no compute and
+  survives a restart.
+
+Requires the Pushary [Partner plan](https://pushary.com/agent-notifications-integration).
+
+## Install
+
+```bash
+pip install pushary-langgraph
+```
+
+Set `PUSHARY_API_KEY` (get it in your [dashboard](https://pushary.com/dashboard/settings)).
+
+## Connect a phone once
+
+```python
+from pushary_langgraph import connect
+
+link = connect("user_123")  # show this to your end-user; one tap connects their phone
+```
+
+## Ask a human inside a node
+
+```python
+from pushary_langgraph import ask_human
+
+def approval_node(state):
+    d = ask_human("Approve this transfer?", external_id=state["user_id"], node="approval")
+    return {"approved": d["approved"]}
+```
+
+`ask_human` blocks, polls durably, and fails closed. The idempotency key is derived
+from `external_id + node + question`, so a node that re-runs on resume hits the same
+decision instead of paging the human twice.
+
+## Durable interrupt
+
+```python
+from pushary_langgraph import pushary_interrupt
+
+def approval_node(state):
+    answer = pushary_interrupt(
+        "Approve this transfer?",
+        external_id=state["user_id"],
+        node="approval",
+        callback_url=os.environ["PUSHARY_CALLBACK_URL"],  # omit to block instead of park
+    )
+    return {"approved": answer == "yes"}
+```
+
+With a `callback_url`, the node opens the decision and calls LangGraph's `interrupt()`
+to park the graph (a checkpointer is required). Keep any code before the call
+idempotent, the whole node re-runs on resume.
+
+### Resume from the webhook
+
+```python
+from pushary_langgraph import resolve_pushary_callback, SIGNATURE_HEADER
+from langgraph.types import Command
+
+# POST /pushary/callback
+def callback(request):
+    raw = request.body
+    cb = resolve_pushary_callback(raw, request.headers.get(SIGNATURE_HEADER), os.environ["PUSHARY_WEBHOOK_SECRET"])
+    if not cb:
+        return ("bad signature", 401)
+    thread_id = lookup_thread(cb["correlationId"])  # your own correlationId -> thread_id map
+    graph.invoke(Command(resume=cb["answer"]), {"configurable": {"thread_id": thread_id}})
+    return ("ok", 200)
+```
+
+## API
+
+- `connect(external_id, *, api_key=None, base_url=None)` — enroll an end-user's phone, returns the link.
+- `ask_human(question, *, external_id, type="confirm", options=None, node=..., ...)` — blocking, returns the decision dict.
+- `pushary_interrupt(question, *, external_id, node=..., callback_url=None, ...)` — blocking, or durable when `callback_url` is set.
+- `resolve_pushary_callback(raw_body, signature, secret)` — verify + parse a callback into `{correlationId, answer, approved, ...}`.
+- `describe_answer(type, result)`, `is_affirmative(answer)`, `deterministic_key(parts)`, `SIGNATURE_HEADER`.
+
+## License
+
+MIT

pushary_langgraph-0.1.0/README.md

@@ -0,0 +1,89 @@
+# pushary-langgraph
+
+Human-in-the-loop for [LangGraph](https://langchain-ai.github.io/langgraph/) and
+LangChain. Ask a real human to approve, and get the answer on their phone. Two seams:
+
+- **A blocking `ask_human`** you call from inside a node.
+- **A durable `pushary_interrupt`** that parks the graph with LangGraph's native
+  `interrupt()` and resumes on a signed webhook, so a long wait holds no compute and
+  survives a restart.
+
+Requires the Pushary [Partner plan](https://pushary.com/agent-notifications-integration).
+
+## Install
+
+```bash
+pip install pushary-langgraph
+```
+
+Set `PUSHARY_API_KEY` (get it in your [dashboard](https://pushary.com/dashboard/settings)).
+
+## Connect a phone once
+
+```python
+from pushary_langgraph import connect
+
+link = connect("user_123")  # show this to your end-user; one tap connects their phone
+```
+
+## Ask a human inside a node
+
+```python
+from pushary_langgraph import ask_human
+
+def approval_node(state):
+    d = ask_human("Approve this transfer?", external_id=state["user_id"], node="approval")
+    return {"approved": d["approved"]}
+```
+
+`ask_human` blocks, polls durably, and fails closed. The idempotency key is derived
+from `external_id + node + question`, so a node that re-runs on resume hits the same
+decision instead of paging the human twice.
+
+## Durable interrupt
+
+```python
+from pushary_langgraph import pushary_interrupt
+
+def approval_node(state):
+    answer = pushary_interrupt(
+        "Approve this transfer?",
+        external_id=state["user_id"],
+        node="approval",
+        callback_url=os.environ["PUSHARY_CALLBACK_URL"],  # omit to block instead of park
+    )
+    return {"approved": answer == "yes"}
+```
+
+With a `callback_url`, the node opens the decision and calls LangGraph's `interrupt()`
+to park the graph (a checkpointer is required). Keep any code before the call
+idempotent, the whole node re-runs on resume.
+
+### Resume from the webhook
+
+```python
+from pushary_langgraph import resolve_pushary_callback, SIGNATURE_HEADER
+from langgraph.types import Command
+
+# POST /pushary/callback
+def callback(request):
+    raw = request.body
+    cb = resolve_pushary_callback(raw, request.headers.get(SIGNATURE_HEADER), os.environ["PUSHARY_WEBHOOK_SECRET"])
+    if not cb:
+        return ("bad signature", 401)
+    thread_id = lookup_thread(cb["correlationId"])  # your own correlationId -> thread_id map
+    graph.invoke(Command(resume=cb["answer"]), {"configurable": {"thread_id": thread_id}})
+    return ("ok", 200)
+```
+
+## API
+
+- `connect(external_id, *, api_key=None, base_url=None)` — enroll an end-user's phone, returns the link.
+- `ask_human(question, *, external_id, type="confirm", options=None, node=..., ...)` — blocking, returns the decision dict.
+- `pushary_interrupt(question, *, external_id, node=..., callback_url=None, ...)` — blocking, or durable when `callback_url` is set.
+- `resolve_pushary_callback(raw_body, signature, secret)` — verify + parse a callback into `{correlationId, answer, approved, ...}`.
+- `describe_answer(type, result)`, `is_affirmative(answer)`, `deterministic_key(parts)`, `SIGNATURE_HEADER`.
+
+## License
+
+MIT

pushary_langgraph-0.1.0/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pushary-langgraph"
+version = "0.1.0"
+description = "Human-in-the-loop for LangGraph and LangChain: a blocking ask_human, plus a durable interrupt()/Command resume that reaches your user on their phone."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Pushary", email = "business@pushary.com" }]
+keywords = [
+    "langgraph",
+    "langchain",
+    "human-in-the-loop",
+    "ai-agents",
+    "approvals",
+    "interrupt",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+dependencies = [
+    "pushary>=1.3.2",
+    "langgraph>=1.0,<2",
+]
+
+[project.urls]
+Homepage = "https://pushary.com"
+Documentation = "https://pushary.com/docs/agents/adapters"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pushary_langgraph"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/pushary_langgraph",
+    "README.md",
+    "LICENSE",
+    "tests",
+]

pushary_langgraph-0.1.0/src/pushary_langgraph/__init__.py

@@ -0,0 +1,191 @@
+"""Human-in-the-loop for LangGraph and LangChain, powered by Pushary.
+
+Two seams over the durable two-call contract (``enroll`` + ``decisions.ask``):
+
+- ``ask_human`` / ``pushary_interrupt`` without a callback: a blocking approval you
+  call from inside a node. It polls durably and fails closed.
+- ``pushary_interrupt`` with a ``callback_url``: parks the graph with LangGraph's
+  native ``interrupt()`` and resumes on Pushary's signed webhook, so an hour-long
+  wait holds no compute and survives a restart.
+
+Zero framework import at module load: LangGraph is imported lazily, only on the
+durable path, so the blocking helpers work (and test) without it installed.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Dict, List, Optional
+
+from pushary import (
+    PusharyServer,
+    SIGNATURE_HEADER,
+    deterministic_key,
+    is_approved,
+    parse_decision_callback,
+    verify_webhook_signature,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "connect",
+    "ask_human",
+    "pushary_interrupt",
+    "describe_answer",
+    "resolve_pushary_callback",
+    "is_affirmative",
+    "deterministic_key",
+    "SIGNATURE_HEADER",
+    "__version__",
+]
+
+
+def _client(api_key: Optional[str] = None, base_url: Optional[str] = None) -> PusharyServer:
+    key = api_key or os.environ.get("PUSHARY_API_KEY")
+    if not key:
+        raise ValueError("Pushary: set PUSHARY_API_KEY or pass api_key=... to the LangGraph helpers.")
+    return PusharyServer(api_key=key, base_url=base_url)
+
+
+def _idempotency_key(external_id: str, node: str, question: str) -> str:
+    return deterministic_key([external_id, node, question])
+
+
+def is_affirmative(answer: Optional[str]) -> bool:
+    """Fail-closed yes/no check for a confirm answer."""
+    return is_approved("answered", "confirm", answer)
+
+
+def connect(external_id: str, *, api_key: Optional[str] = None, base_url: Optional[str] = None) -> str:
+    """Connect one end-user's phone (keyless). Returns a single-use link to show them."""
+    return _client(api_key, base_url).enroll(external_id)["universalLink"]
+
+
+def ask_human(
+    question: str,
+    *,
+    external_id: str,
+    type: str = "confirm",
+    options: Optional[List[str]] = None,
+    node: str = "ask-human",
+    context: Optional[str] = None,
+    agent_name: Optional[str] = None,
+    timeout_seconds: Optional[float] = None,
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Blocking ask (Pattern A): create a decision and poll durably until answered.
+
+    Returns the decision dict (``decisionId``, ``status``, ``answered``, ``value``,
+    ``type``, fail-closed ``approved``). The idempotency key is derived from
+    external_id + node + question, so a node that re-runs on resume hits the same
+    decision instead of paging the human twice.
+    """
+    return _client(api_key, base_url).decisions.ask(
+        question,
+        type=type,
+        options=options,
+        external_id=external_id,
+        context=context,
+        agent_name=agent_name,
+        timeout_seconds=timeout_seconds,
+        idempotency_key=_idempotency_key(external_id, node, question),
+    )
+
+
+def describe_answer(type: str, result: Dict[str, Any]) -> str:
+    """Turn a decision outcome into an unambiguous instruction for the model."""
+    if not result.get("answered"):
+        return (
+            f"No answer (status: {result.get('status')}). "
+            "Treat this as NOT approved and do not proceed."
+        )
+    if type == "confirm":
+        return (
+            "The human approved. You may proceed."
+            if result.get("approved")
+            else "The human declined. Do not proceed."
+        )
+    return f"The human answered: {result.get('value') or ''}"
+
+
+def resolve_pushary_callback(
+    raw_body: Any, signature: Optional[str], secret: str
+) -> Optional[Dict[str, Any]]:
+    """Verify a callback signature and parse it, or return None.
+
+    Feed ``answer`` into ``graph.invoke(Command(resume=answer), config)``.
+    """
+    if not verify_webhook_signature(raw_body, signature, secret):
+        return None
+    cb = parse_decision_callback(raw_body)
+    if not cb:
+        return None
+    return {
+        "correlationId": cb.get("correlationId"),
+        "answer": cb.get("answer"),
+        "value": cb.get("value"),
+        "approved": is_affirmative(cb.get("answer")),
+        "context": cb.get("context"),
+        "answeredAt": cb.get("answeredAt"),
+    }
+
+
+def pushary_interrupt(
+    question: str,
+    *,
+    external_id: str,
+    node: str = "hitl",
+    type: str = "confirm",
+    options: Optional[List[str]] = None,
+    callback_url: Optional[str] = None,
+    context: Optional[str] = None,
+    agent_name: Optional[str] = None,
+    timeout_seconds: Optional[float] = None,
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+) -> Optional[str]:
+    """Ask a human from inside a LangGraph node.
+
+    - ``callback_url`` omitted (Pattern A): blocks, polls durably, returns the answer
+      (or None if fail-closed). Zero extra infra, holds the run open for the wait.
+    - ``callback_url`` set (Pattern B): opens the decision, then calls LangGraph's
+      ``interrupt()`` to park the graph in your checkpointer. Resume with
+      ``Command(resume=answer)`` from the signed webhook. Holds no idle compute.
+
+    The whole node re-runs on resume, so keep code before this call idempotent. The
+    decision's idempotency key is derived from external_id + node + question, so the
+    re-run lands on the same decision.
+    """
+    idem = _idempotency_key(external_id, node, question)
+    px = _client(api_key, base_url)
+
+    if not callback_url:
+        d = px.decisions.ask(
+            question,
+            type=type,
+            options=options,
+            external_id=external_id,
+            context=context,
+            agent_name=agent_name,
+            timeout_seconds=timeout_seconds,
+            idempotency_key=idem,
+        )
+        return d.get("value") if d.get("answered") else None
+
+    px.decisions.create(
+        question,
+        type=type,
+        options=options,
+        external_id=external_id,
+        context=context,
+        agent_name=agent_name,
+        callback_url=callback_url,
+        idempotency_key=idem,
+        wait=False,
+    )
+    # Lazy import: only the durable path needs LangGraph installed.
+    from langgraph.types import interrupt
+
+    return interrupt({"pushary": "decision", "question": question, "external_id": external_id})

pushary_langgraph-0.1.0/tests/test_langgraph.py

@@ -0,0 +1,149 @@
+"""Tests for pushary_langgraph. Framework-free: LangGraph is never imported here,
+so the blocking helpers are exercised without it installed. HTTP is mocked by
+swapping the module's ``_client`` for a stub.
+"""
+
+import hashlib
+import hmac
+import json
+import unittest
+
+import pushary_langgraph as plg
+
+
+class FakeDecisions:
+    def __init__(self, ask_result=None, create_result=None):
+        self.ask_calls = []
+        self.create_calls = []
+        self._ask_result = ask_result or {}
+        self._create_result = create_result or {}
+
+    def ask(self, question, **kwargs):
+        self.ask_calls.append({"question": question, **kwargs})
+        return self._ask_result
+
+    def create(self, question, **kwargs):
+        self.create_calls.append({"question": question, **kwargs})
+        return self._create_result
+
+
+class FakeClient:
+    def __init__(self, decisions=None, enroll_result=None):
+        self.decisions = decisions or FakeDecisions()
+        self._enroll_result = enroll_result or {}
+        self.enroll_calls = []
+
+    def enroll(self, external_id):
+        self.enroll_calls.append(external_id)
+        return self._enroll_result
+
+
+class WithFakeClient:
+    """Patch plg._client to return a supplied FakeClient for the duration of a test."""
+
+    def __init__(self, client):
+        self.client = client
+        self._orig = None
+
+    def __enter__(self):
+        self._orig = plg._client
+        plg._client = lambda *a, **k: self.client
+        return self.client
+
+    def __exit__(self, *exc):
+        plg._client = self._orig
+
+
+SECRET = "whsec_test"
+
+
+def sign(body: str) -> str:
+    return hmac.new(SECRET.encode(), body.encode(), hashlib.sha256).hexdigest()
+
+
+class ConnectTests(unittest.TestCase):
+    def test_connect_returns_universal_link(self):
+        client = FakeClient(enroll_result={"universalLink": "https://pushary.com/e/tok"})
+        with WithFakeClient(client):
+            link = plg.connect("user_1")
+        self.assertEqual(link, "https://pushary.com/e/tok")
+        self.assertEqual(client.enroll_calls, ["user_1"])
+
+
+class AskHumanTests(unittest.TestCase):
+    def test_ask_human_forwards_deterministic_idempotency_key(self):
+        decisions = FakeDecisions(ask_result={"status": "answered", "answered": True, "value": "yes", "approved": True})
+        with WithFakeClient(FakeClient(decisions=decisions)):
+            out = plg.ask_human("Approve?", external_id="user_1", node="approval")
+        self.assertTrue(out["approved"])
+        call = decisions.ask_calls[0]
+        self.assertEqual(call["external_id"], "user_1")
+        self.assertTrue(call["idempotency_key"])
+        # same input -> same key (re-run safe)
+        expected = plg.deterministic_key(["user_1", "approval", "Approve?"])
+        self.assertEqual(call["idempotency_key"], expected)
+
+
+class PusharyInterruptTests(unittest.TestCase):
+    def test_blocking_pattern_returns_value_when_answered(self):
+        decisions = FakeDecisions(ask_result={"answered": True, "value": "yes"})
+        with WithFakeClient(FakeClient(decisions=decisions)):
+            answer = plg.pushary_interrupt("Approve?", external_id="user_1", node="n")
+        self.assertEqual(answer, "yes")
+
+    def test_blocking_pattern_fails_closed_when_unanswered(self):
+        decisions = FakeDecisions(ask_result={"answered": False, "status": "expired"})
+        with WithFakeClient(FakeClient(decisions=decisions)):
+            answer = plg.pushary_interrupt("Approve?", external_id="user_1", node="n")
+        self.assertIsNone(answer)
+
+    def test_durable_pattern_opens_decision_with_callback(self):
+        # callback_url set -> Pattern B calls create() then imports langgraph.interrupt.
+        # langgraph is not installed in this test env, so we assert the create call happened
+        # and that the lazy import is what raises (not our code path).
+        decisions = FakeDecisions(create_result={"decisionId": "d1", "status": "pending"})
+        with WithFakeClient(FakeClient(decisions=decisions)):
+            with self.assertRaises(ImportError):
+                plg.pushary_interrupt(
+                    "Approve?", external_id="user_1", node="n", callback_url="https://x/cb"
+                )
+        create = decisions.create_calls[0]
+        self.assertEqual(create["callback_url"], "https://x/cb")
+        self.assertEqual(create["wait"], False)
+
+
+class DescribeAnswerTests(unittest.TestCase):
+    def test_formats_every_outcome(self):
+        self.assertIn("approved", plg.describe_answer("confirm", {"answered": True, "approved": True}))
+        self.assertIn("declined", plg.describe_answer("confirm", {"answered": True, "approved": False}))
+        self.assertIn("NOT approved", plg.describe_answer("confirm", {"answered": False, "status": "expired"}))
+        self.assertIn("B", plg.describe_answer("select", {"answered": True, "value": "B"}))
+
+
+class ResolveCallbackTests(unittest.TestCase):
+    def test_verifies_parses_and_folds_approved(self):
+        body = json.dumps({"correlationId": "d1", "answer": "yes", "answeredAt": "", "context": "t-1"})
+        out = plg.resolve_pushary_callback(body, sign(body), SECRET)
+        self.assertEqual(out["correlationId"], "d1")
+        self.assertTrue(out["approved"])
+        self.assertEqual(out["context"], "t-1")
+
+    def test_rejects_bad_signature(self):
+        body = json.dumps({"correlationId": "d1", "answer": "yes", "answeredAt": ""})
+        self.assertIsNone(plg.resolve_pushary_callback(body, "nope", SECRET))
+
+    def test_decline_is_not_approved(self):
+        body = json.dumps({"correlationId": "d2", "answer": "no", "answeredAt": ""})
+        out = plg.resolve_pushary_callback(body, sign(body), SECRET)
+        self.assertFalse(out["approved"])
+
+
+class IsAffirmativeTests(unittest.TestCase):
+    def test_fail_closed(self):
+        self.assertTrue(plg.is_affirmative("yes"))
+        self.assertFalse(plg.is_affirmative("no"))
+        self.assertFalse(plg.is_affirmative(None))
+
+
+if __name__ == "__main__":
+    unittest.main()