agent-wait 0.2.0__tar.gz → 0.3.0__tar.gz

{agent_wait-0.2.0 → agent_wait-0.3.0}/.gitignore

@@ -10,10 +10,10 @@ __pycache__/
 build/
 cdk.out/
 reports/*.log
-
-# generated by the docs workflow from README.md / CHANGELOG.md
-docs/index.md
-docs/changelog.md
-# build output
-dist/
-site/
+
+# generated by the docs workflow from README.md / CHANGELOG.md
+docs/index.md
+docs/changelog.md
+# build output
+dist/
+site/

{agent_wait-0.2.0 → agent_wait-0.3.0}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Kamaljeet Singh
-
-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.
+MIT License
+
+Copyright (c) 2026 Kamaljeet Singh
+
+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.

agent_wait-0.3.0/PKG-INFO

@@ -0,0 +1,218 @@
+Metadata-Version: 2.5
+Name: agent-wait
+Version: 0.3.0
+Summary: Get a LangGraph interrupt out of the process -- to a topic, a queue, a webhook, a table -- so anyone can answer it, and the answer back in.
+Project-URL: Homepage, https://skamalj.github.io/agent-wait/
+Project-URL: Documentation, https://skamalj.github.io/agent-wait/
+Project-URL: Source, https://github.com/skamalj/agent-wait
+Project-URL: Issues, https://github.com/skamalj/agent-wait/issues
+Project-URL: Changelog, https://github.com/skamalj/agent-wait/blob/main/CHANGELOG.md
+Author-email: Kamaljeet Singh <skamalj@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,approval,durable,human-in-the-loop,interrupt,langgraph,serverless
+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.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# agent-wait
+
+[![PyPI](https://img.shields.io/pypi/v/agent-wait.svg)](https://pypi.org/project/agent-wait/)
+[![CI](https://github.com/skamalj/agent-wait/actions/workflows/ci.yml/badge.svg)](https://github.com/skamalj/agent-wait/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/skamalj/agent-wait/blob/main/LICENSE)
+
+**Get a LangGraph interrupt out of the process, and the answer back in.**
+
+When a node calls `interrupt()`, the graph pauses and the interrupt is handed to whatever
+called `invoke()` — and that is where LangGraph stops. There is no built-in way to tell
+anyone *else* that a question was asked, and no built-in way for anyone else to answer
+it. The moment the question has to reach a person on Slack, an approvals dashboard, a
+ticket queue or another service, you are writing that code yourself — whether your agent
+is a server that runs for a year or a Lambda that is gone in seconds.
+
+agent-wait is that code. It takes the interrupt and puts it somewhere people can see it —
+a topic, a queue, a webhook, a database row — with everything needed to answer it in one
+envelope, and documents the shape of the answer so the return leg is one `if`.
+
+```bash
+pip install agent-wait langgraph-wait          # core + LangGraph
+pip install agent-wait-aws                     # SNS / SQS / EventBridge / DynamoDB announcers
+```
+
+## The whole thing
+
+**In the graph** — one line, where the decision belongs:
+
+```python
+from agent_wait import WaitPolicy
+from langgraph_wait import ask
+
+
+def review(state):
+    decision = ask(
+        {"kind": "refund_approval", "order_id": state["order_id"], "amount": state["amount"]},
+        policy=WaitPolicy(
+            timeout="P3D",
+            default={"action": "reject"},
+            allowed_actions=("approve", "reject"),
+            tags={"approver_group": "finance"},
+        ),
+    )
+    return {"decision": decision}  # exactly what the approver sent
+```
+
+`ask()` is a thin wrapper over `interrupt()`; the policy rides along inside the
+interrupt value. A plain `interrupt(value)` works too, with the default policy.
+
+**After the run** — one call:
+
+```python
+from agent_wait_aws import SnsAnnounce
+from langgraph_wait import publish_interrupts
+
+result = graph.invoke(value, {"configurable": {"thread_id": thread_id}})
+publish_interrupts(result, thread_id, announce=[SnsAnnounce(topic_arn)])
+```
+
+It reads `result["__interrupt__"]` — `Interrupt.id` and `Interrupt.value`, nothing else —
+and hands one envelope per question to the announcers. No graph handle, no `get_state()`,
+no checkpointer. If nothing interrupted, it does nothing.
+
+**When the answer comes back** — the one `if` you write:
+
+```python
+from langgraph.types import Command
+
+if "question_id" in message:  # an answer
+    value = Command(resume={message["question_id"]: message["answer"]})
+else:  # a start
+    value = message["input"]
+
+result = graph.invoke(value, {"configurable": {"thread_id": message["thread_id"]}})
+publish_interrupts(result, message["thread_id"], announce)
+```
+
+That is the complete integration. A duplicate answer runs nothing — LangGraph ignores a
+resume for a question the thread has moved past — so there is nothing to check.
+
+## Or tag the tool
+
+```python
+from langgraph_wait import hitl
+
+
+@tool
+@hitl(WaitPolicy(timeout="P1D", default={"action": "reject"}, tags={"approver_group": "finance"}))
+def issue_refund(order_id: str, amount: int) -> str: ...
+```
+
+`@hitl` calls `ask()` with `{tool, args}` before the tool runs. `{"action": "approve"}`
+runs it (optionally with edited `args`); anything else is returned to the model as the
+tool's result. It also registers the policy by tool name, so questions raised by
+LangChain's `HumanInTheLoopMiddleware` — which batches several tool calls into one
+interrupt — are published with it.
+
+**Async mode — the thread does not park:**
+
+```python
+@tool
+@hitl(FINANCE, mode="async", announce=[SnsAnnounce(topic_arn), DynamoDbAnnounce(table)])
+def issue_refund(order_id: str, amount: int) -> str: ...
+```
+
+The decorator *is* the publisher: the tool call announces the question and returns
+`{"status": "pending_approval", "question_id": ...}` without running. The graph carries
+on; nothing is parked; nothing to call after the run. The decision arrives later as a new
+message and your graph acts on it. This is the mode for a single-thread channel like
+WhatsApp, where the approver is not the person on the thread.
+
+## What goes out
+
+```json
+{
+  "type": "wait.created",
+  "thread_id": "order-4471",
+  "question_id": "a1b2c3d4e5f60718",
+  "question": { "kind": "refund_approval", "amount": 41000 },
+  "allowed_actions": ["approve", "reject"],
+  "expires_at": "2026-09-14T09:00:00Z",
+  "default": { "action": "reject" },
+  "source": { "tool": "issue_refund" },
+  "reply_with": { "thread_id": "order-4471", "question_id": "a1b2c3d4e5f60718", "answer": null }
+}
+```
+
+`reply_with` is a filled-in stub: copy it, set `answer`, send it back. Whatever goes in
+`answer` is what `ask()` returns — verbatim.
+
+Full schema, the recommended answer shape, and how to deduplicate:
+[Message formats](https://skamalj.github.io/agent-wait/message-formats/).
+
+## Announcers
+
+Subclass `BaseAnnounce`, write one method:
+
+```python
+from agent_wait import BaseAnnounce
+
+
+class RedisAnnounce(BaseAnnounce):
+    name = "redis"
+
+    def __init__(self, client, **kw):
+        super().__init__(**kw)
+        self.client = client
+
+    def deliver(self, envelope, transition):
+        self.client.set(envelope.dedupe_key, envelope.to_json())
+```
+
+A raise inside `deliver()` becomes a log line; the run completes. Shipped:
+
+| Adapter | Package | Where the question lands |
+|---|---|---|
+| `WebhookAnnounce` | `agent-wait` | A URL. JSON POST, optional HMAC-SHA256 signature. Stdlib only. |
+| `LogAnnounce` | `agent-wait` | A structured log line. The question never reaches INFO. |
+| `InMemoryAnnounce` | `agent-wait` | A list. For tests. |
+| `SnsAnnounce` | `agent-wait-aws` | A topic; `tags` become message attributes for subscription filters. |
+| `SqsAnnounce` | `agent-wait-aws` | A queue; on FIFO, grouped by thread, deduplicated on the stable key. |
+| `EventBridgeAnnounce` | `agent-wait-aws` | A bus. Notices partial failures behind a 200. |
+| `DynamoDbAnnounce` | `agent-wait-aws` | **A row**, `status=open`, with a GSI an approvals UI can query. Write-only. |
+
+[Writing an announcer](https://skamalj.github.io/agent-wait/writing-an-announcer/).
+
+## What the library does *not* do
+
+- **Receive answers.** No endpoint, no validation, no ledger reads. The `if` above is yours.
+- **Enforce anything.** `expires_at`, `default`, `answer_ttl`, `allowed_actions` are
+  published so the consumer has the asker's intent. Acting on them is the consumer's.
+- **Store anything.** LangGraph's checkpoint is the only state in interrupt mode; in
+  async mode there is none unless you keep one.
+
+## One LangGraph 1.2.x behaviour to know
+
+Two tools that each call `interrupt()`, dispatched by one `ToolNode`, get the **same
+interrupt id** ([#6626](https://github.com/langchain-ai/langgraph/issues/6626)), and only
+one surfaces per run ([#6624](https://github.com/langchain-ai/langgraph/issues/6624)).
+A different question under an identical id defeats deduplication. Use one interrupting
+tool per node, or `HumanInTheLoopMiddleware`, which batches them into one interrupt.
+Pinned by a test that fails if LangGraph changes it.
+
+## Layout
+
+```
+packages/agent-wait        core: Question, WaitPolicy, the envelope, publish(), announcers. No deps.
+packages/langgraph-wait    ask(), @hitl, publish_interrupts(). The only LangGraph import.
+packages/agent-wait-aws    four announce adapters, and a CDK stack for the example.
+examples/refund_agent      a graph and a host, deployed to Lambda behind SQS.
+docs/                      message contract, architecture, announcer guide, consumer guide.
+```
+
+MIT. Issues and PRs at [github.com/skamalj/agent-wait](https://github.com/skamalj/agent-wait).

agent_wait-0.3.0/README.md

@@ -0,0 +1,194 @@
+# agent-wait
+
+[![PyPI](https://img.shields.io/pypi/v/agent-wait.svg)](https://pypi.org/project/agent-wait/)
+[![CI](https://github.com/skamalj/agent-wait/actions/workflows/ci.yml/badge.svg)](https://github.com/skamalj/agent-wait/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/skamalj/agent-wait/blob/main/LICENSE)
+
+**Get a LangGraph interrupt out of the process, and the answer back in.**
+
+When a node calls `interrupt()`, the graph pauses and the interrupt is handed to whatever
+called `invoke()` — and that is where LangGraph stops. There is no built-in way to tell
+anyone *else* that a question was asked, and no built-in way for anyone else to answer
+it. The moment the question has to reach a person on Slack, an approvals dashboard, a
+ticket queue or another service, you are writing that code yourself — whether your agent
+is a server that runs for a year or a Lambda that is gone in seconds.
+
+agent-wait is that code. It takes the interrupt and puts it somewhere people can see it —
+a topic, a queue, a webhook, a database row — with everything needed to answer it in one
+envelope, and documents the shape of the answer so the return leg is one `if`.
+
+```bash
+pip install agent-wait langgraph-wait          # core + LangGraph
+pip install agent-wait-aws                     # SNS / SQS / EventBridge / DynamoDB announcers
+```
+
+## The whole thing
+
+**In the graph** — one line, where the decision belongs:
+
+```python
+from agent_wait import WaitPolicy
+from langgraph_wait import ask
+
+
+def review(state):
+    decision = ask(
+        {"kind": "refund_approval", "order_id": state["order_id"], "amount": state["amount"]},
+        policy=WaitPolicy(
+            timeout="P3D",
+            default={"action": "reject"},
+            allowed_actions=("approve", "reject"),
+            tags={"approver_group": "finance"},
+        ),
+    )
+    return {"decision": decision}  # exactly what the approver sent
+```
+
+`ask()` is a thin wrapper over `interrupt()`; the policy rides along inside the
+interrupt value. A plain `interrupt(value)` works too, with the default policy.
+
+**After the run** — one call:
+
+```python
+from agent_wait_aws import SnsAnnounce
+from langgraph_wait import publish_interrupts
+
+result = graph.invoke(value, {"configurable": {"thread_id": thread_id}})
+publish_interrupts(result, thread_id, announce=[SnsAnnounce(topic_arn)])
+```
+
+It reads `result["__interrupt__"]` — `Interrupt.id` and `Interrupt.value`, nothing else —
+and hands one envelope per question to the announcers. No graph handle, no `get_state()`,
+no checkpointer. If nothing interrupted, it does nothing.
+
+**When the answer comes back** — the one `if` you write:
+
+```python
+from langgraph.types import Command
+
+if "question_id" in message:  # an answer
+    value = Command(resume={message["question_id"]: message["answer"]})
+else:  # a start
+    value = message["input"]
+
+result = graph.invoke(value, {"configurable": {"thread_id": message["thread_id"]}})
+publish_interrupts(result, message["thread_id"], announce)
+```
+
+That is the complete integration. A duplicate answer runs nothing — LangGraph ignores a
+resume for a question the thread has moved past — so there is nothing to check.
+
+## Or tag the tool
+
+```python
+from langgraph_wait import hitl
+
+
+@tool
+@hitl(WaitPolicy(timeout="P1D", default={"action": "reject"}, tags={"approver_group": "finance"}))
+def issue_refund(order_id: str, amount: int) -> str: ...
+```
+
+`@hitl` calls `ask()` with `{tool, args}` before the tool runs. `{"action": "approve"}`
+runs it (optionally with edited `args`); anything else is returned to the model as the
+tool's result. It also registers the policy by tool name, so questions raised by
+LangChain's `HumanInTheLoopMiddleware` — which batches several tool calls into one
+interrupt — are published with it.
+
+**Async mode — the thread does not park:**
+
+```python
+@tool
+@hitl(FINANCE, mode="async", announce=[SnsAnnounce(topic_arn), DynamoDbAnnounce(table)])
+def issue_refund(order_id: str, amount: int) -> str: ...
+```
+
+The decorator *is* the publisher: the tool call announces the question and returns
+`{"status": "pending_approval", "question_id": ...}` without running. The graph carries
+on; nothing is parked; nothing to call after the run. The decision arrives later as a new
+message and your graph acts on it. This is the mode for a single-thread channel like
+WhatsApp, where the approver is not the person on the thread.
+
+## What goes out
+
+```json
+{
+  "type": "wait.created",
+  "thread_id": "order-4471",
+  "question_id": "a1b2c3d4e5f60718",
+  "question": { "kind": "refund_approval", "amount": 41000 },
+  "allowed_actions": ["approve", "reject"],
+  "expires_at": "2026-09-14T09:00:00Z",
+  "default": { "action": "reject" },
+  "source": { "tool": "issue_refund" },
+  "reply_with": { "thread_id": "order-4471", "question_id": "a1b2c3d4e5f60718", "answer": null }
+}
+```
+
+`reply_with` is a filled-in stub: copy it, set `answer`, send it back. Whatever goes in
+`answer` is what `ask()` returns — verbatim.
+
+Full schema, the recommended answer shape, and how to deduplicate:
+[Message formats](https://skamalj.github.io/agent-wait/message-formats/).
+
+## Announcers
+
+Subclass `BaseAnnounce`, write one method:
+
+```python
+from agent_wait import BaseAnnounce
+
+
+class RedisAnnounce(BaseAnnounce):
+    name = "redis"
+
+    def __init__(self, client, **kw):
+        super().__init__(**kw)
+        self.client = client
+
+    def deliver(self, envelope, transition):
+        self.client.set(envelope.dedupe_key, envelope.to_json())
+```
+
+A raise inside `deliver()` becomes a log line; the run completes. Shipped:
+
+| Adapter | Package | Where the question lands |
+|---|---|---|
+| `WebhookAnnounce` | `agent-wait` | A URL. JSON POST, optional HMAC-SHA256 signature. Stdlib only. |
+| `LogAnnounce` | `agent-wait` | A structured log line. The question never reaches INFO. |
+| `InMemoryAnnounce` | `agent-wait` | A list. For tests. |
+| `SnsAnnounce` | `agent-wait-aws` | A topic; `tags` become message attributes for subscription filters. |
+| `SqsAnnounce` | `agent-wait-aws` | A queue; on FIFO, grouped by thread, deduplicated on the stable key. |
+| `EventBridgeAnnounce` | `agent-wait-aws` | A bus. Notices partial failures behind a 200. |
+| `DynamoDbAnnounce` | `agent-wait-aws` | **A row**, `status=open`, with a GSI an approvals UI can query. Write-only. |
+
+[Writing an announcer](https://skamalj.github.io/agent-wait/writing-an-announcer/).
+
+## What the library does *not* do
+
+- **Receive answers.** No endpoint, no validation, no ledger reads. The `if` above is yours.
+- **Enforce anything.** `expires_at`, `default`, `answer_ttl`, `allowed_actions` are
+  published so the consumer has the asker's intent. Acting on them is the consumer's.
+- **Store anything.** LangGraph's checkpoint is the only state in interrupt mode; in
+  async mode there is none unless you keep one.
+
+## One LangGraph 1.2.x behaviour to know
+
+Two tools that each call `interrupt()`, dispatched by one `ToolNode`, get the **same
+interrupt id** ([#6626](https://github.com/langchain-ai/langgraph/issues/6626)), and only
+one surfaces per run ([#6624](https://github.com/langchain-ai/langgraph/issues/6624)).
+A different question under an identical id defeats deduplication. Use one interrupting
+tool per node, or `HumanInTheLoopMiddleware`, which batches them into one interrupt.
+Pinned by a test that fails if LangGraph changes it.
+
+## Layout
+
+```
+packages/agent-wait        core: Question, WaitPolicy, the envelope, publish(), announcers. No deps.
+packages/langgraph-wait    ask(), @hitl, publish_interrupts(). The only LangGraph import.
+packages/agent-wait-aws    four announce adapters, and a CDK stack for the example.
+examples/refund_agent      a graph and a host, deployed to Lambda behind SQS.
+docs/                      message contract, architecture, announcer guide, consumer guide.
+```
+
+MIT. Issues and PRs at [github.com/skamalj/agent-wait](https://github.com/skamalj/agent-wait).

{agent_wait-0.2.0 → agent_wait-0.3.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "agent-wait"
-version = "0.2.0"
-description = "Publish a LangGraph agent's interrupts to the outside world so a human can answer them -- from a queue, a Lambda, anywhere the process does not stick around."
+version = "0.3.0"
+description = "Get a LangGraph interrupt out of the process -- to a topic, a queue, a webhook, a table -- so anyone can answer it, and the answer back in."
 readme = "README.md"
 requires-python = ">=3.12"
 license = "MIT"

{agent_wait-0.2.0 → agent_wait-0.3.0}/src/agent_wait/__init__.py

@@ -1,81 +1,78 @@
-"""agent-wait: publish an agent's interrupts to the outside world.
-
-A graph node asks a question and pauses:
-
-    from langgraph_wait import ask
-
-    decision = ask({"kind": "refund_approval", "amount": amount},
-                   policy=WaitPolicy(timeout="P3D", allowed_actions=("approve", "reject")))
-
-The host runs the graph through a publisher, and whatever the graph parked on goes out
-to wherever people can see it:
-
-    agent = WaitPublisher(LangGraphAdapter(graph), announce=[SnsAnnounce(topic_arn)])
-
-    agent.invoke(payload, thread_id)
-
-That is the whole library. It publishes questions and it reports what a thread is parked
-on. It does not receive answers, hold state, mint credentials or run timers -- see
-`docs/migrating-from-0.1.md` for what that means if you are coming from v0.1.
-"""
-
-from .announce import (
-    AnnounceAdapter,
-    BaseAnnounce,
-    CompositeAnnounce,
-    FailingAnnounce,
-    InMemoryAnnounce,
-    LogAnnounce,
-    WebhookAnnounce,
-    verify_signature,
-)
-from .errors import PolicyError, QuestionTooLarge, WaitError
-from .model import (
-    MAX_QUESTION_BYTES,
-    Clock,
-    EntryPoint,
-    FakeClock,
-    PendingInterrupt,
-    SystemClock,
-    Transition,
-    WaitEnvelope,
-    canonical_json,
-    check_question_size,
-    iso,
-    new_ulid,
-)
-from .policy import WaitPolicy, parse_duration
-from .publisher import FrameworkAdapter, WaitPublisher
-
-__version__ = "0.2.0"
-
-__all__ = [
-    "MAX_QUESTION_BYTES",
-    "AnnounceAdapter",
-    "BaseAnnounce",
-    "Clock",
-    "CompositeAnnounce",
-    "EntryPoint",
-    "FailingAnnounce",
-    "FakeClock",
-    "FrameworkAdapter",
-    "InMemoryAnnounce",
-    "LogAnnounce",
-    "PendingInterrupt",
-    "PolicyError",
-    "QuestionTooLarge",
-    "SystemClock",
-    "Transition",
-    "WaitEnvelope",
-    "WaitError",
-    "WaitPolicy",
-    "WaitPublisher",
-    "WebhookAnnounce",
-    "__version__",
-    "canonical_json",
-    "check_question_size",
-    "iso",
-    "new_ulid",
-    "parse_duration",
-    "verify_signature",
-]
+"""agent-wait: announce an agent's interrupts to the outside world.
+
+A graph node asks a question and pauses:
+
+    from langgraph_wait import ask
+
+    decision = ask({"kind": "refund_approval", "amount": amount},
+                   policy=WaitPolicy(timeout="P3D", allowed_actions=("approve", "reject")))
+
+After the run, the host announces whatever it parked on:
+
+    result = graph.invoke(value, config)
+    publish_interrupts(result, thread_id, announce=[SnsAnnounce(topic_arn)])
+
+That is the whole library. It builds one envelope per interrupt and hands it to the
+announcers. It does not run the graph, receive answers, hold state or run timers.
+"""
+
+from .announce import (
+    AnnounceAdapter,
+    BaseAnnounce,
+    CompositeAnnounce,
+    FailingAnnounce,
+    InMemoryAnnounce,
+    LogAnnounce,
+    WebhookAnnounce,
+    verify_signature,
+)
+from .errors import PolicyError, QuestionTooLarge, WaitError
+from .model import (
+    MAX_QUESTION_BYTES,
+    Clock,
+    EntryPoint,
+    FakeClock,
+    Question,
+    SystemClock,
+    Transition,
+    WaitEnvelope,
+    canonical_json,
+    check_question_size,
+    iso,
+    new_ulid,
+)
+from .policy import WaitPolicy, parse_duration
+from .publish import build_envelope, publish
+
+__version__ = "0.3.0"
+
+__all__ = [
+    "MAX_QUESTION_BYTES",
+    "AnnounceAdapter",
+    "BaseAnnounce",
+    "Clock",
+    "CompositeAnnounce",
+    "EntryPoint",
+    "FailingAnnounce",
+    "FakeClock",
+    "InMemoryAnnounce",
+    "LogAnnounce",
+    "PolicyError",
+    "Question",
+    "QuestionTooLarge",
+    "SystemClock",
+    "Transition",
+    "WaitEnvelope",
+    "WaitError",
+    "WaitPolicy",
+    "WebhookAnnounce",
+    "__version__",
+    "build_envelope",
+    "canonical_json",
+    "check_question_size",
+    "iso",
+    "new_ulid",
+    "parse_duration",
+    "publish",
+    "verify_signature",
+]

{agent_wait-0.2.0 → agent_wait-0.3.0}/src/agent_wait/announce/base.py

@@ -89,7 +89,7 @@ class BaseAnnounce(ABC):
         except Exception:
             # A backend being unreachable must not fail a run that has already parked.
             self._log.exception(
-                "%s failed for interrupt %s (%s)", type(self).__name__, envelope.interrupt_id, transition
+                "%s failed for interrupt %s (%s)", type(self).__name__, envelope.question_id, transition
             )
 
     @abstractmethod