macp-sdk-python 0.13.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

macp_sdk/__init__.py

@@ -120,6 +120,7 @@ from .task import (
 from .validation import (
     validate_commitment_hash,
     validate_confidence,
+    validate_max_suspend_ms,
     validate_participant_count,
     validate_participants,
     validate_progress_scope,
@@ -133,6 +134,7 @@ from .validation import (
     validate_vote,
 )
 from .watchers import (
+    TERMINAL_SESSION_LIFECYCLE_EVENT_NAMES,
     ModeRegistryWatcher,
     PolicyChange,
     PolicyWatcher,
@@ -173,6 +175,7 @@ __all__ = [
     "SESSION_NOT_FOUND",
     "SESSION_NOT_OPEN",
     "STANDARD_MODES",
+    "TERMINAL_SESSION_LIFECYCLE_EVENT_NAMES",
     "UNAUTHENTICATED",
     "UNBOUNDED",
     "UNKNOWN_POLICY_VERSION",
@@ -263,6 +266,7 @@ __all__ = [
     "serialize_message",
     "validate_commitment_hash",
     "validate_confidence",
+    "validate_max_suspend_ms",
     "validate_participant_count",
     "validate_participants",
     "validate_progress_scope",

macp_sdk/agent/participant.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import threading
 from dataclasses import dataclass, field
 from typing import Any
 
@@ -418,9 +419,22 @@ class Participant:
             mode=mode,
             participant_id=participant_id,
         )
-        self._last_phase: str | None = None
+        # Seed from the projection's own initial phase: that phase is a
+        # constructor artifact, not an observed transition, so firing
+        # on_phase_change for it would report a change that never happened.
+        # This matters most for a mid-session joiner, whose first envelope
+        # otherwise re-announces a phase the session entered before it
+        # attached. None when no projection is registered for the mode -- the
+        # phase path is skipped entirely in that case.
+        self._last_phase: str | None = (
+            self._projection.phase if self._projection is not None else None
+        )
         self._transport = transport
         self._cancel_callback_server: Any | None = None
+        # Non-reentrant by design: an RLock would let a handler calling
+        # run() recursively (same thread) through, only to deadlock on the
+        # transport instead of raising a clear error.
+        self._run_lock = threading.Lock()
 
     @property
     def participant_id(self) -> str:
@@ -484,6 +498,9 @@ class Participant:
         point. As a fallback (for envelopes projections don't model — e.g.
         ``SessionCancel``), we fire terminal on the message type itself so
         clients always get a ``stop`` signal for end-of-session envelopes.
+        The fallback only fires when the projection has not already
+        reported a terminal phase, so a ``SessionCancel`` arriving after a
+        ``Commitment`` cannot produce a second ``on_terminal``.
         """
         if self._projection is not None:
             self._projection.apply_envelope(envelope)
@@ -496,6 +513,9 @@ class Participant:
         self._dispatcher.dispatch(message, ctx)
 
         fired_terminal = False
+        already_terminal = (
+            self._projection is not None and self._projection.phase in TERMINAL_PHASES
+        )
 
         # Phase transition path — drives both on_phase_change and on_terminal.
         if self._projection is not None:
@@ -521,7 +541,7 @@ class Participant:
         # Fallback for envelopes projections don't transition phase on —
         # principally ``SessionCancel``. Keeps terminal dispatch reliable
         # while the phase-driven path remains primary.
-        if not fired_terminal and envelope.message_type == "SessionCancel":
+        if not fired_terminal and not already_terminal and envelope.message_type == "SessionCancel":
             self._dispatcher.dispatch_terminal(TerminalResult(state="Cancelled"))
             self._stopped = True
 
@@ -566,8 +586,39 @@ class Participant:
         emits SessionStart + kickoff before opening the stream.
 
         Dispatches received events to registered handlers until the session
-        reaches a terminal state or ``stop()`` is called.
+        reaches a terminal state or ``stop()`` is called. The loop exits
+        after the current envelope finishes dispatching, not after the
+        next one arrives.
+
+        Teardown contract: a ``run()`` that ends with the participant
+        stopped also releases the cancel-callback listener (if one was
+        attached); a ``run()`` that ends with the participant still
+        runnable leaves it bound so a subsequent ``run()`` keeps its
+        cancel endpoint.
+
+        Not re-entrant: a *concurrent* call (from another thread, while
+        this one is still inside the loop) raises :class:`MacpSessionError`
+        instead of silently starting a second transport and interleaving
+        dispatches into shared state. This is a deliberate divergence from
+        ``macp-sdk-typescript``, whose ``run()`` returns silently in the
+        same situation -- a no-op is tolerable there because its single
+        event loop makes a second call almost always a same-task
+        programmer mistake, whereas a second Python thread believing it is
+        running an agent that is in fact doing nothing is a silent
+        liveness bug. A *sequential* call, made after a prior ``run()`` has
+        returned, is unaffected and behaves exactly as before.
         """
+        if not self._run_lock.acquire(blocking=False):
+            raise MacpSessionError(
+                f"Participant.run() is already executing for session {self._session_id!r}; "
+                "run() is not re-entrant"
+            )
+        try:
+            self._run()
+        finally:
+            self._run_lock.release()
+
+    def _run(self) -> None:
         logger.info(
             "participant %s joining session %s (mode=%s, initiator=%s)",
             self._participant_id,
@@ -600,8 +651,27 @@ class Participant:
                     self._process_envelope(message.raw)
                 else:
                     self._process_message(message)
+                if self._stopped:
+                    # A handler (or another thread) called stop() while this
+                    # envelope was being dispatched -- including the terminal
+                    # dispatch in _process_envelope, which sets _stopped itself.
+                    # Without this check the loop blocks on transport.start()'s
+                    # next yield, which on a quiet session may never come.
+                    break
         finally:
-            transport.stop()
+            try:
+                transport.stop()
+            except Exception:
+                logger.debug("transport stop failed during run() teardown", exc_info=True)
+            if self._stopped:
+                # Release the cancel-callback listener only when this
+                # participant has actually stopped -- which is also exactly
+                # when a further run() would be a no-op (the one-shot early
+                # return above reads the same flag). So the server is still
+                # bound on every exit from which a sequential run() can still
+                # do something, and is released on every exit after which it
+                # cannot.
+                self._close_cancel_callback_server()
 
     def _emit_initiator_envelopes(self) -> None:
         """Emit SessionStart + kickoff envelope as the initiator."""
@@ -658,6 +728,21 @@ class Participant:
         """Manually process a single envelope (for testing or polling transports)."""
         self._process_envelope(envelope)
 
+    def _close_cancel_callback_server(self) -> None:
+        """Close the bound cancel-callback HTTP server, if one was attached.
+
+        Idempotent and exception-safe: called from both :meth:`stop` and
+        ``run()``'s exit path (the latter only when this participant has
+        actually stopped), either of which may run first, or both.
+        """
+        server = self._cancel_callback_server
+        if server is not None:
+            self._cancel_callback_server = None
+            try:
+                server.close()
+            except Exception:
+                logger.exception("cancel_callback server close failed")
+
     def stop(self) -> None:
         """Signal the event loop to stop.
 
@@ -680,19 +765,17 @@ class Participant:
             cancel = getattr(transport, "cancel", None)
             if callable(cancel):
                 cancel()
-        server = self._cancel_callback_server
-        if server is not None:
-            self._cancel_callback_server = None
-            try:
-                server.close()
-            except Exception:
-                logger.exception("cancel_callback server close failed")
+        self._close_cancel_callback_server()
 
     def attach_cancel_callback_server(self, server: Any) -> None:
         """Attach a :class:`CancelCallbackServer` to this participant.
 
-        The server's lifetime is then tied to :meth:`stop` — the event
-        loop exit (or an incoming cancel POST that calls ``stop``) shuts
-        it down.
+        The server's lifetime is then tied to an actual stop: an
+        incoming cancel POST (or any other caller of :meth:`stop`)
+        shuts it down, and so does ``run()`` returning with the
+        participant stopped (e.g. a terminal envelope). A ``run()``
+        that returns with the participant still runnable leaves it
+        bound, so a subsequent ``run()`` keeps the same cancel
+        endpoint.
         """
         self._cancel_callback_server = server

macp_sdk/agent/runner.py

@@ -6,6 +6,7 @@ import json
 import os
 from typing import Any
 
+from .._logging import logger
 from ..auth import AuthConfig
 from ..client import MacpClient
 from ..constants import DEFAULT_POLICY_VERSION
@@ -36,6 +37,23 @@ def _decode_extensions(raw: Any) -> dict[str, bytes]:
     bootstrap) defaults to ``{}``; a *present* value of the wrong type (a
     list, a string, ...) is equally malformed and raises rather than
     silently vanishing (#97 follow-up).
+
+    **Known, accepted ambiguity (issue #121):** trying base64 first means a
+    plain string that *happens* to also be syntactically valid base64 (e.g.
+    ``"abcd"`` or ``"pack"`` -- any string whose length is a multiple of 4
+    over the base64 alphabet) silently decodes as base64 bytes instead of
+    being treated as the literal string a bootstrap author intended. There
+    is no way to tell the two apart from the string alone, and this SDK is
+    the canonical source ``macp-sdk-typescript`` mirrors for interop, so
+    changing the heuristic would need a coordinated, versioned decision
+    across both SDKs (and likely a wire-shape change), not a local fix.
+    Decided: keep the heuristic as-is rather than add a disambiguation
+    mechanism -- it is a diagnosability/correctness-on-the-margins wart, not
+    a live bug, and the ``logger.debug`` call below at least makes a
+    base64-decode *failure* observable. A value that round-trips through
+    *both* interpretations without the caller noticing is the accepted
+    cost; callers who need an unambiguous literal string should route it
+    through a different field instead of ``extensions``.
     """
     if raw is None:
         return {}
@@ -51,6 +69,10 @@ def _decode_extensions(raw: Any) -> dict[str, bytes]:
             try:
                 decoded[str(key)] = base64.b64decode(value, validate=True)
             except (binascii.Error, ValueError):
+                logger.debug(
+                    "bootstrap extensions[%r] is not valid base64; using its raw UTF-8 bytes",
+                    key,
+                )
                 decoded[str(key)] = value.encode("utf-8")
         else:
             raise ValueError(

macp_sdk/agent/strategies.py

@@ -6,6 +6,7 @@ from dataclasses import dataclass
 from typing import Any, Protocol
 
 from ..envelope import infer_outcome_positive
+from ..validation import validate_confidence, validate_recommendation
 from .types import HandlerContext, IncomingMessage, MessageHandler, SessionInfo
 
 # ── Evaluation ───────────────────────────────────────────────────────
@@ -26,9 +27,6 @@ class EvaluationStrategy(Protocol):
     def evaluate(self, proposal: dict[str, Any], context: SessionInfo) -> EvaluationResult: ...
 
 
-_VALID_RECOMMENDATIONS = frozenset({"APPROVE", "REVIEW", "BLOCK", "REJECT"})
-
-
 def evaluation_handler(strategy: EvaluationStrategy) -> MessageHandler:
     """Create a MessageHandler that evaluates proposals using the given strategy.
 
@@ -41,14 +39,8 @@ def evaluation_handler(strategy: EvaluationStrategy) -> MessageHandler:
         if message.message_type != "Proposal":
             return
         result = strategy.evaluate(message.payload, ctx.session)
-        recommendation = result.recommendation.upper()
-        if recommendation not in _VALID_RECOMMENDATIONS:
-            raise ValueError(
-                f"invalid recommendation {result.recommendation!r}: "
-                "must be one of APPROVE, REVIEW, BLOCK, REJECT"
-            )
-        if not (0.0 <= result.confidence <= 1.0):
-            raise ValueError(f"confidence must be in [0.0, 1.0], got {result.confidence}")
+        recommendation = validate_recommendation(result.recommendation)
+        validate_confidence(result.confidence)
         ctx.log(
             "evaluation: recommendation=%s confidence=%.2f reason=%s",
             recommendation,
@@ -254,7 +246,9 @@ def majority_voter(
     """Built-in voting strategy that votes ``APPROVE`` once the fraction of
     qualifying (non-``REVIEW``) evaluations recommending ``APPROVE``, for the
     most recently evaluated proposal, meets ``positive_threshold`` --
-    otherwise ``ABSTAIN``.
+    otherwise ``ABSTAIN``. ``should_vote`` applies the same qualifying/latest-
+    proposal rule: it returns ``True`` only when there is at least one
+    qualifying evaluation for ``decide_vote`` to actually decide from.
 
     Both ``should_vote`` and ``decide_vote`` read only from
     ``projection.evaluations``, never from votes already cast (issue #93 item
@@ -279,13 +273,29 @@ def majority_voter(
         def should_vote(self, projection: Any) -> bool:
             if projection is None:
                 return False
-            # Gate on Evaluations, not on votes already cast -- voting_handler
-            # already only calls should_vote() on an incoming Evaluation
-            # message, so this mirrors typescript-sdk's
-            # majorityVoter.shouldVote (strategies.ts:88:
-            # `projection.evaluations.length > 0`).
-            evaluations = getattr(projection, "evaluations", None)
-            return bool(evaluations)
+            evaluations = list(getattr(projection, "evaluations", None) or [])
+            if not evaluations:
+                return False
+            # Agree with decide_vote(): it votes on the most recently evaluated
+            # proposal and counts only qualifying (non-REVIEW) evaluations for
+            # that proposal, so should_vote() must ask the same question.
+            # RFC-MACP-0007 §4 (rfcs/RFC-MACP-0007-decision-mode.md:73): REVIEW
+            # evaluations "do not block or approve a proposal; they serve as
+            # informational analysis records only" -- a set of only REVIEWs has
+            # nothing decisive to vote on.
+            #
+            # Cross-SDK note: macp-sdk-typescript's majorityVoter
+            # (src/agent/strategies.ts:90-98) applies the same REVIEW filter but
+            # does NOT scope to a proposal -- its decideVote counts every
+            # decisive evaluation in the session. Python scopes both methods to
+            # the latest proposal, which is the stricter and more correct
+            # behaviour for a multi-proposal session (the vote is cast for one
+            # proposal_id). The difference is deliberate; see plan issue #121.
+            proposal_id = evaluations[-1].proposal_id
+            return any(
+                e.proposal_id == proposal_id and e.recommendation.upper() != "REVIEW"
+                for e in evaluations
+            )
 
         def decide_vote(self, projection: Any) -> VoteResult:
             evaluations = list(getattr(projection, "evaluations", None) or [])
@@ -334,7 +344,11 @@ def majority_committer(
     and the quorum has been met.
 
     Args:
-        quorum_size: Minimum number of votes before commitment (default ``1``).
+        quorum_size: Minimum number of positive votes for the winning proposal
+            required before committing (default ``1``). Counted from
+            ``vote_totals().get(winner, 0)``, not from the session's total
+            vote count, so votes cast for proposals that lost no longer help
+            clear the bar.
         action: The commitment action string (default ``"commit"``).
         authority_scope: The commitment authority scope (default ``"session"``).
     """
@@ -350,11 +364,20 @@ def majority_committer(
         def should_commit(self, projection: Any) -> bool:
             if projection is None:
                 return False
-            totals = projection.vote_totals()
-            total_votes = sum(totals.values())
-            if total_votes < self._quorum:
+            winner = projection.majority_winner()
+            if winner is None:
                 return False
-            return projection.majority_winner() is not None
+            # quorum_size is the bar for the WINNING proposal, not for the
+            # session's total vote count: vote_totals() is keyed by
+            # proposal_id (projections.py:167-181), so summing its values
+            # across proposals let the bar be cleared by votes cast for
+            # proposals that lost. Worked example, measured against a real
+            # DecisionProjection: p1=2 APPROVE, p2=1 APPROVE, quorum_size=3
+            # -> the old sum is 2+1=3 >= 3 and majority_winner() is "p1", so
+            # it committed a proposal holding 2 of the 3 votes the caller
+            # asked for. Matches macp-sdk-typescript's majorityCommitter
+            # (src/agent/strategies.ts:163-168).
+            return projection.vote_totals().get(winner, 0) >= self._quorum
 
         def decide_commitment(self, projection: Any) -> CommitmentResult:
             winner = projection.majority_winner()

macp_sdk/auth.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from .errors import MacpSessionError
+
 
 @dataclass(frozen=True)
 class AuthConfig:
@@ -23,7 +25,7 @@ class AuthConfig:
 
     def __post_init__(self) -> None:
         if not self.bearer_token:
-            raise ValueError("bearer_token is required")
+            raise MacpSessionError("bearer_token is required")
 
     @classmethod
     def for_dev_agent(cls, agent_id: str, *, expected_sender: str | None = None) -> AuthConfig:

macp_sdk/client.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import queue
 import threading
-from collections.abc import Callable, Iterator, Sequence
+from collections.abc import Callable, Generator, Iterator, Sequence
 from typing import Any
 
 import grpc
@@ -134,6 +134,21 @@ UNBOUNDED = _UnboundedTimeout()
 TimeoutValue = float | None | _UnboundedTimeout
 
 
+def _cancel_quietly(call: Any) -> None:
+    """Best-effort cancel of a server-streaming gRPC call.
+
+    Called from each ``watch_*`` generator's ``finally``, so it runs on
+    normal exhaustion, on an exception, and on ``GeneratorExit`` when a
+    consumer abandons the stream. Cancelling an already-finished call is
+    a no-op in grpcio; a cancel that raises must not replace whatever
+    the generator was already propagating.
+    """
+    try:
+        call.cancel()
+    except Exception:
+        logger.debug("stream cancel failed", exc_info=True)
+
+
 class MacpStream:
     _END = object()
 
@@ -674,6 +689,14 @@ class MacpClient:
     def list_roots(
         self, *, auth: AuthConfig | None = None, timeout: TimeoutValue = None
     ) -> core_pb2.ListRootsResponse:
+        """List the roots the runtime exposes.
+
+        The runtime does not populate roots yet and returns an empty list;
+        since runtime v0.5.0 it advertises this up front via
+        ``capabilities.roots.list_changed: false`` in ``Initialize``. The RPC
+        is wired and forward-compatible -- callers should treat an empty list
+        as "no roots advertised," not as an error.
+        """
         return self.stub.ListRoots(
             core_pb2.ListRootsRequest(),
             metadata=self._metadata(auth),
@@ -738,7 +761,7 @@ class MacpClient:
         *,
         auth: AuthConfig | None = None,
         timeout: TimeoutValue = None,
-    ) -> Iterator[core_pb2.WatchSessionsResponse]:
+    ) -> Generator[core_pb2.WatchSessionsResponse, None, None]:
         """Server-streaming RPC: yields session lifecycle events.
 
         The runtime emits an initial ``EVENT_TYPE_CREATED`` frame for every
@@ -760,6 +783,8 @@ class MacpClient:
             yield from call
         except grpc.RpcError as exc:
             raise self._transport_error_from_rpc(exc) from exc
+        finally:
+            _cancel_quietly(call)
 
     def register_ext_mode(
         self,
@@ -938,7 +963,7 @@ class MacpClient:
 
     def watch_policies(
         self, *, auth: AuthConfig | None = None, timeout: TimeoutValue = None
-    ) -> Iterator[policy_pb2.WatchPoliciesResponse]:
+    ) -> Generator[policy_pb2.WatchPoliciesResponse, None, None]:
         """Server-streaming RPC: yields governance policy change events.
 
         Auth is forwarded when available (``auth`` arg or ``client.auth``) but
@@ -955,6 +980,8 @@ class MacpClient:
             yield from call
         except grpc.RpcError as exc:
             raise self._transport_error_from_rpc(exc) from exc
+        finally:
+            _cancel_quietly(call)
 
     def open_stream(
         self, *, auth: AuthConfig | None = None, timeout: TimeoutValue = None
@@ -968,7 +995,7 @@ class MacpClient:
 
     def watch_mode_registry(
         self, *, auth: AuthConfig | None = None, timeout: TimeoutValue = None
-    ) -> Iterator[core_pb2.WatchModeRegistryResponse]:
+    ) -> Generator[core_pb2.WatchModeRegistryResponse, None, None]:
         """Server-streaming RPC: yields mode registry change events.
 
         Auth is forwarded when available but not required.
@@ -983,10 +1010,12 @@ class MacpClient:
             yield from call
         except grpc.RpcError as exc:
             raise self._transport_error_from_rpc(exc) from exc
+        finally:
+            _cancel_quietly(call)
 
     def watch_roots(
         self, *, auth: AuthConfig | None = None, timeout: TimeoutValue = None
-    ) -> Iterator[core_pb2.WatchRootsResponse]:
+    ) -> Generator[core_pb2.WatchRootsResponse, None, None]:
         """Server-streaming RPC: yields root change events.
 
         The runtime advertises ``roots.list_changed: false`` and does not yet
@@ -1003,10 +1032,12 @@ class MacpClient:
             yield from call
         except grpc.RpcError as exc:
             raise self._transport_error_from_rpc(exc) from exc
+        finally:
+            _cancel_quietly(call)
 
     def watch_signals(
         self, *, auth: AuthConfig | None = None, timeout: TimeoutValue = None
-    ) -> Iterator[core_pb2.WatchSignalsResponse]:
+    ) -> Generator[core_pb2.WatchSignalsResponse, None, None]:
         """Server-streaming RPC: yields ambient signal envelopes.
 
         Requires authentication since runtime v0.5.0 — an unauthenticated
@@ -1025,6 +1056,8 @@ class MacpClient:
             yield from call
         except grpc.RpcError as exc:
             raise self._transport_error_from_rpc(exc) from exc
+        finally:
+            _cancel_quietly(call)
 
     def send_signal(
         self,

macp_sdk/envelope.py

@@ -14,7 +14,7 @@ from .constants import (
     MACP_VERSION,
 )
 from .errors import MacpSessionError
-from .validation import validate_commitment_hash
+from .validation import validate_commitment_hash, validate_max_suspend_ms
 
 # ── Outcome inference ────────────────────────────────────────────────
 
@@ -79,10 +79,7 @@ def build_session_start_payload(
     client-side here with a clear message. proto3 does not serialize a scalar
     ``0``, so the default keeps byte-compatibility with pre-0.1.5 payloads.
     """
-    if max_suspend_ms < 0:
-        raise MacpSessionError(
-            f"max_suspend_ms must be >= 0 (0 selects the runtime default), got {max_suspend_ms}"
-        )
+    validate_max_suspend_ms(max_suspend_ms)
     kwargs: dict[str, object] = dict(
         intent=intent,
         participants=list(participants),

macp_sdk/handoff.py

@@ -82,8 +82,8 @@ class HandoffProjection(BaseProjection):
                 if handoff.status == "offered":
                     handoff.status = "context_sent"
                 handoff.context_content_type = p.content_type
-            if self.phase == "OfferPending":
-                self._set_phase("ContextSharing")
+                if self.phase == "OfferPending":
+                    self._set_phase("ContextSharing")
             return
 
         if mt == "HandoffAccept":

macp_sdk/projections.py

@@ -67,6 +67,31 @@ class DecisionProjection(BaseProjection):
                 rationale=payload.rationale,
                 sender=envelope.sender,
             )
+            # A Proposal opens the evaluation window: the runtime advances the
+            # session's phase when it accepts the Proposal
+            # (macp-runtime/crates/macp-modes/src/mode/decision.rs:172) and then
+            # *requires* that phase before it will accept an Evaluation or
+            # Objection at all (ensure_can_deliberate, same file :71-77, gating
+            # :187 and :212) -- so reporting "Proposal" in this window describes a
+            # state the session is demonstrably not in. macp-sdk-typescript's
+            # DecisionProjection advances here too. "Proposal" is still the initial
+            # phase set in __init__ -- it is observable before the first mode
+            # message, it just no longer survives the Proposal itself.
+            #
+            # Guarded on the phase still being the initial one, NOT unconditional:
+            # _set_phase (base_projection.py) blocks regression only out of
+            # "Committed", so an unconditional call here would let a Proposal
+            # redelivered under a distinct message_id rewind "Voting" ->
+            # "Evaluation". RFC-MACP-0007 §5 rule 6
+            # (rfcs/RFC-MACP-0007-decision-mode.md:94) says a runtime MUST reject
+            # any Proposal/Evaluation/Objection after the first accepted Vote, and
+            # a message the runtime must reject certainly must not rewind our local
+            # phase. Same shape as handoff.py:85's `if self.phase ==
+            # "OfferPending"` guard. (macp-sdk-typescript/src/projections/
+            # decision.ts:55 is unconditional and has this latent gap even though
+            # its own Vote arm guards at :124-126 -- do not copy it.)
+            if self.phase == "Proposal":
+                self._set_phase("Evaluation")
             return
 
         if message_type == "Evaluation":
@@ -100,6 +125,17 @@ class DecisionProjection(BaseProjection):
         if message_type == "Vote":
             payload = decision_pb2.VotePayload()
             payload.ParseFromString(envelope.payload)
+            if payload.proposal_id not in self.proposals:
+                # A Vote for a proposal this projection never saw is ignored
+                # entirely -- no vote record, no phase advance, and deliberately
+                # NO anomaly. Rejecting an unknown proposal_id is the runtime's
+                # obligation (it has the full session state); a projection is a
+                # local, possibly partial view, and a mid-session joiner whose
+                # replay window starts after the Proposal legitimately never saw
+                # it. Recording an anomaly here would fire on conforming
+                # sessions. Same split, same shape as the guard issue #119
+                # shipped in proposal.py's Reject branch.
+                return
             existing = self.votes.get(payload.proposal_id, {}).get(envelope.sender)
             if existing is not None:
                 # First-wins (RFC-MACP-0007 §5.3: "the first accepted Vote

macp_sdk/quorum.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import warnings
 from dataclasses import dataclass
 
 from macp.modes.quorum.v1 import quorum_pb2
@@ -23,7 +24,25 @@ class ApprovalRequestRecord:
     action: str
     summary: str
     required_approvals: int
-    requester: str
+    sender: str
+
+    # ── Deprecated alias (issue #120 / multiagentcoordinationprotocol#177) ──
+    # ``requester`` is kept as a read-only, INSTANCE-level property alias for
+    # one minor version, removed at this SDK's next major version. See
+    # ``ProposalRecord.proposer`` in proposal.py for the full rationale this
+    # mechanism shares: a plain same-named class attribute alias is not an
+    # option on a ``@dataclass(slots=True)``, but a property is not a field
+    # and is untouched by the slots transformation. No setter is defined:
+    # nothing in this module ever assigns ``.requester``.
+    @property
+    def requester(self) -> str:
+        warnings.warn(
+            "ApprovalRequestRecord.requester is deprecated; "
+            "use ApprovalRequestRecord.sender instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.sender
 
 
 @dataclass(slots=True)
@@ -68,7 +87,7 @@ class QuorumProjection(BaseProjection):
                 action=p.action,
                 summary=p.summary,
                 required_approvals=p.required_approvals,
-                requester=envelope.sender,
+                sender=envelope.sender,
             )
             self._set_phase("Voting")
             return
@@ -103,6 +122,12 @@ class QuorumProjection(BaseProjection):
         # Approve/Reject/Abstain arms, each rejecting when
         # state.ballots.contains_key(&env.sender), confirmed at runtime
         # v0.8.6) -- RFC-0011 itself is silent on that.
+        if request_id not in self.requests:
+            # Same projection-vs-runtime split as projections.py's Vote guard:
+            # rejecting an unknown request_id is the runtime's obligation, and a
+            # mid-session joiner may legitimately never have seen the
+            # ApprovalRequest, so this is a silent no-op with no anomaly.
+            return
         sender = envelope.sender
         sender_map = self.ballots.setdefault(request_id, {})
         existing = sender_map.get(sender)

macp_sdk/task.py

@@ -25,19 +25,37 @@ class TaskRecord:
     title: str
     instructions: str
     requested_assignee: str
-    requester: str
+    sender: str
     status: str = "requested"
     progress: float = 0.0
     assignee: str | None = None
     deadline_unix_ms: int = 0
     input: bytes = b""
 
+    # ── Deprecated alias (issue #120 / multiagentcoordinationprotocol#177) ──
+    # ``requester`` is kept as a read-only, INSTANCE-level property alias for
+    # one minor version, removed at this SDK's next major version. See
+    # ``ProposalRecord.proposer`` in proposal.py for the full rationale this
+    # mechanism shares: a plain same-named class attribute alias is not an
+    # option on a ``@dataclass(slots=True)``, but a property is not a field
+    # and is untouched by the slots transformation. No setter is defined:
+    # nothing in this module ever assigns ``.requester``.
+    @property
+    def requester(self) -> str:
+        warnings.warn(
+            "TaskRecord.requester is deprecated; use TaskRecord.sender instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.sender
+
 
 @dataclass(slots=True)
 class TaskRejectRecord:
     task_id: str
     assignee: str
     reason: str
+    sender: str = ""
 
 
 @dataclass(slots=True)
@@ -46,6 +64,7 @@ class TaskUpdateRecord:
     status: str
     progress: float
     message: str
+    sender: str = ""
 
 
 @dataclass(slots=True)
@@ -54,6 +73,7 @@ class TaskCompleteRecord:
     assignee: str
     summary: str
     output: bytes
+    sender: str = ""
 
 
 @dataclass(slots=True)
@@ -63,6 +83,7 @@ class TaskFailRecord:
     error_code: str
     reason: str
     retryable: bool
+    sender: str = ""
 
 
 # ---------------------------------------------------------------------------
@@ -108,7 +129,7 @@ class TaskProjection(BaseProjection):
                 title=p.title,
                 instructions=p.instructions,
                 requested_assignee=p.requested_assignee,
-                requester=envelope.sender,
+                sender=envelope.sender,
                 status="requested",
                 progress=0.0,
                 assignee=None,
@@ -165,8 +186,12 @@ class TaskProjection(BaseProjection):
             self.rejections.append(
                 TaskRejectRecord(
                     task_id=p.task_id,
+                    # `assignee` is who the work is about (payload-declared,
+                    # falling back to the sender); `sender` is who sent this
+                    # message (envelope truth, never substituted).
                     assignee=p.assignee or envelope.sender,
                     reason=p.reason,
+                    sender=envelope.sender,
                 )
             )
             if p.task_id in self.tasks:
@@ -191,6 +216,7 @@ class TaskProjection(BaseProjection):
                     status=p.status,
                     progress=p.progress,
                     message=p.message,
+                    sender=envelope.sender,
                 )
             )
             if p.task_id in self.tasks:
@@ -207,6 +233,7 @@ class TaskProjection(BaseProjection):
                     assignee=p.assignee or envelope.sender,
                     summary=p.summary,
                     output=p.output,
+                    sender=envelope.sender,
                 )
             )
             if p.task_id in self.tasks:
@@ -225,6 +252,7 @@ class TaskProjection(BaseProjection):
                     error_code=p.error_code,
                     reason=p.reason,
                     retryable=p.retryable,
+                    sender=envelope.sender,
                 )
             )
             if p.task_id in self.tasks:

macp_sdk/validation.py

@@ -5,6 +5,7 @@ All validation functions raise ``MacpSessionError`` on failure.
 
 from __future__ import annotations
 
+import math
 import re
 from collections.abc import Sequence
 
@@ -96,7 +97,10 @@ def validate_recommendation(value: str) -> str:
 
 def validate_confidence(value: float) -> None:
     """Validate that *value* is in [0.0, 1.0]."""
-    if value < 0.0 or value > 1.0:
+    # NaN < 0.0 and NaN > 1.0 are both False, so a bare range check silently
+    # *accepts* NaN; inf was already rejected incidentally by > 1.0 and is
+    # now rejected explicitly.
+    if not math.isfinite(value) or value < 0.0 or value > 1.0:
         raise MacpSessionError(f"confidence must be in [0.0, 1.0], got {value}")
 
 
@@ -160,10 +164,26 @@ def validate_progress_scope(session_id: str, mode: str) -> None:
 
 def validate_ttl_ms(ttl_ms: int) -> None:
     """Validate that *ttl_ms* is in [1, 86_400_000]."""
-    if ttl_ms < 1 or ttl_ms > _MAX_TTL_MS:
+    if not math.isfinite(ttl_ms) or ttl_ms < 1 or ttl_ms > _MAX_TTL_MS:
         raise MacpSessionError(f"ttl_ms must be in [1, {_MAX_TTL_MS}], got {ttl_ms}")
 
 
+def validate_max_suspend_ms(max_suspend_ms: int) -> None:
+    """Validate that *max_suspend_ms* is >= 0 (``0`` selects the runtime default).
+
+    No upper bound is imposed: the runtime does not cap the value either
+    -- ``macp-runtime/src/runtime.rs:487-495`` binds whatever positive
+    value it is given as the session's ``bound_max_suspend_ms`` and only
+    falls back to its own 7-day default when the field is ``0``. The
+    sibling TypeScript SDK's ``validateMaxSuspendMs``
+    (``src/validation.ts:134-139``) is identical, deliberately.
+    """
+    if not math.isfinite(max_suspend_ms) or max_suspend_ms < 0:
+        raise MacpSessionError(
+            f"max_suspend_ms must be >= 0 (0 selects the runtime default), got {max_suspend_ms}"
+        )
+
+
 def validate_participants(participants: Sequence[str], *, allow_empty: bool = False) -> None:
     """Validate participant list: non-empty, no duplicates, within count limit.
 
@@ -205,7 +225,15 @@ def validate_session_start(
     ``allow_empty_participants`` forwards to :func:`validate_participants` --
     see its docstring for why Decision mode is the one caller that sets it.
     """
-    validate_required_field("intent", intent)
+    # RFC-MACP-0001 §7.1 does not require a non-empty intent, and the
+    # runtime accepts an empty one. ``intent`` is kept in the signature
+    # because this function is public and exported (``__init__.py``), so
+    # removing the parameter would be a breaking change for a fix whose
+    # entire point is to be *less* strict. ``del`` rather than an ARG001
+    # suppression comment: ruff's ARG rules apply to ``src/`` (per-file-
+    # ignores covers ``tests/**`` only), and this states the intent
+    # instead of silencing the check.
+    del intent  # accepted but deliberately unvalidated (RFC-MACP-0001 §7.1)
     validate_participants(participants, allow_empty=allow_empty_participants)
     validate_ttl_ms(ttl_ms)
     validate_required_field("mode_version", mode_version)

macp_sdk/watchers.py

@@ -9,10 +9,13 @@ Each watcher provides three consumption patterns:
 from __future__ import annotations
 
 import warnings
-from collections.abc import Callable, Iterator
+from collections.abc import Callable, Generator
+from contextlib import closing
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 
+from .errors import MacpTransportError
+
 if TYPE_CHECKING:
     from .auth import AuthConfig
     from .client import MacpClient
@@ -26,6 +29,33 @@ class PolicyChange:
     observed_at_unix_ms: int = 0
 
 
+TERMINAL_SESSION_LIFECYCLE_EVENT_NAMES: frozenset[str] = frozenset(
+    {"RESOLVED", "EXPIRED", "CANCELLED"}
+)
+"""Event-type names after which a session emits no further lifecycle events.
+
+``SUSPENDED`` / ``RESUMED`` are deliberately absent: a suspended session
+can still be resumed, so neither is terminal.
+
+Cross-SDK note -- read this before comparing anything against it.
+These are the proto enum names with the ``EVENT_TYPE_`` prefix
+**stripped** (see ``_session_event_name``), which is the shape
+``SessionLifecycleEvent.event_type`` carries in this SDK.
+``macp-sdk-typescript`` exports a differently-shaped set under the
+confusingly similar name ``TERMINAL_SESSION_LIFECYCLE_EVENT_TYPES``
+(``src/watchers.ts:20-24``), holding the **un-stripped** names
+(``"EVENT_TYPE_RESOLVED"``). This constant is named ``..._NAMES``
+rather than ``..._TYPES`` precisely so the two cannot be mistaken for
+the same contract. The value difference is deliberate and will not be
+reconciled by changing Python: the stripped form is this SDK's
+published field *value*, so changing it would break every
+``event_type == "RESOLVED"`` call site with no deprecation path
+available (a value, unlike a name, cannot carry a warning). To test a
+prefixed string from a TypeScript-written log, normalise it first:
+``t.removeprefix("EVENT_TYPE_") in TERMINAL_SESSION_LIFECYCLE_EVENT_NAMES``.
+"""
+
+
 @dataclass(slots=True)
 class SessionLifecycleEvent:
     """A single session lifecycle event from ``WatchSessions``.
@@ -77,8 +107,12 @@ class SessionLifecycleEvent:
     @property
     def is_terminal(self) -> bool:
         """``True`` for RESOLVED, EXPIRED, or CANCELLED — the session won't
-        emit more events. ``SUSPENDED`` / ``RESUMED`` are non-terminal."""
-        return self.event_type in ("RESOLVED", "EXPIRED", "CANCELLED")
+        emit more events. ``SUSPENDED`` / ``RESUMED`` are non-terminal.
+
+        See ``TERMINAL_SESSION_LIFECYCLE_EVENT_NAMES`` for the exported,
+        reusable form of this set.
+        """
+        return self.event_type in TERMINAL_SESSION_LIFECYCLE_EVENT_NAMES
 
 
 class ModeRegistryWatcher:
@@ -88,20 +122,22 @@ class ModeRegistryWatcher:
         self._client = client
         self._auth = auth
 
-    def changes(self) -> Iterator[Any]:
+    def changes(self) -> Generator[Any, None, None]:
         """Yield ``WatchModeRegistryResponse`` items from the runtime stream."""
         yield from self._client.watch_mode_registry(auth=self._auth)
 
     def watch(self, handler: Callable[[Any], None]) -> None:
         """Block and invoke *handler* for each registry change."""
-        for change in self.changes():
-            handler(change)
+        with closing(self.changes()) as stream:
+            for change in stream:
+                handler(change)
 
     def next_change(self) -> Any:
         """Pull a single change from the stream and return it."""
-        for change in self.changes():
-            return change
-        raise RuntimeError("stream ended before receiving a change")
+        with closing(self.changes()) as stream:
+            for change in stream:
+                return change
+        raise MacpTransportError("stream ended before receiving a change")
 
 
 class RootsWatcher:
@@ -111,20 +147,22 @@ class RootsWatcher:
         self._client = client
         self._auth = auth
 
-    def changes(self) -> Iterator[Any]:
+    def changes(self) -> Generator[Any, None, None]:
         """Yield ``WatchRootsResponse`` items from the runtime stream."""
         yield from self._client.watch_roots(auth=self._auth)
 
     def watch(self, handler: Callable[[Any], None]) -> None:
         """Block and invoke *handler* for each root change."""
-        for change in self.changes():
-            handler(change)
+        with closing(self.changes()) as stream:
+            for change in stream:
+                handler(change)
 
     def next_change(self) -> Any:
         """Pull a single change from the stream and return it."""
-        for change in self.changes():
-            return change
-        raise RuntimeError("stream ended before receiving a change")
+        with closing(self.changes()) as stream:
+            for change in stream:
+                return change
+        raise MacpTransportError("stream ended before receiving a change")
 
 
 class SignalWatcher:
@@ -134,26 +172,36 @@ class SignalWatcher:
         self._client = client
         self._auth = auth
 
-    def signals(self) -> Iterator[Any]:
+    def signals(self) -> Generator[Any, None, None]:
         """Yield envelope objects extracted from ``WatchSignalsResponse``.
 
         Forwards the watcher's stored ``auth`` — runtime v0.5.0 requires
         authentication for ``WatchSignals``.
+
+        Wraps the inner ``watch_signals()`` generator in its own
+        ``closing()`` -- a bare ``for`` loop here would only release it
+        by refcounting when this generator is itself closed, which a
+        caller-held reference cycle (or a non-refcounting GC) can defer
+        indefinitely, undermining the whole point of the caller side
+        wrapping *this* generator in ``closing()`` in turn.
         """
-        for response in self._client.watch_signals(auth=self._auth):
-            if hasattr(response, "envelope") and response.envelope.ByteSize() > 0:
-                yield response.envelope
+        with closing(self._client.watch_signals(auth=self._auth)) as responses:
+            for response in responses:
+                if hasattr(response, "envelope") and response.envelope.ByteSize() > 0:
+                    yield response.envelope
 
     def watch(self, handler: Callable[[Any], None]) -> None:
         """Block and invoke *handler* for each signal envelope."""
-        for envelope in self.signals():
-            handler(envelope)
+        with closing(self.signals()) as stream:
+            for envelope in stream:
+                handler(envelope)
 
     def next_signal(self) -> Any:
         """Pull a single signal envelope from the stream and return it."""
-        for envelope in self.signals():
-            return envelope
-        raise RuntimeError("stream ended before receiving a signal")
+        with closing(self.signals()) as stream:
+            for envelope in stream:
+                return envelope
+        raise MacpTransportError("stream ended before receiving a signal")
 
 
 _SESSION_EVENT_PREFIX = "EVENT_TYPE_"
@@ -191,28 +239,36 @@ class SessionLifecycleWatcher:
         self._client = client
         self._auth = auth
 
-    def changes(self) -> Iterator[SessionLifecycleEvent]:
-        """Yield ``SessionLifecycleEvent`` items from the runtime stream."""
-        for response in self._client.watch_sessions(auth=self._auth):
-            event = getattr(response, "event", None)
-            if event is None:
-                continue
-            yield SessionLifecycleEvent(
-                event_type=_session_event_name(event.event_type),
-                observed_at_unix_ms=event.observed_at_unix_ms,
-                session=event.session,
-            )
+    def changes(self) -> Generator[SessionLifecycleEvent, None, None]:
+        """Yield ``SessionLifecycleEvent`` items from the runtime stream.
+
+        Wraps the inner ``watch_sessions()`` generator in its own
+        ``closing()`` -- see ``SignalWatcher.signals()``'s docstring for
+        why a bare ``for`` loop here isn't enough.
+        """
+        with closing(self._client.watch_sessions(auth=self._auth)) as responses:
+            for response in responses:
+                event = getattr(response, "event", None)
+                if event is None:
+                    continue
+                yield SessionLifecycleEvent(
+                    event_type=_session_event_name(event.event_type),
+                    observed_at_unix_ms=event.observed_at_unix_ms,
+                    session=event.session,
+                )
 
     def watch(self, handler: Callable[[SessionLifecycleEvent], None]) -> None:
         """Block and invoke *handler* for each lifecycle event."""
-        for change in self.changes():
-            handler(change)
+        with closing(self.changes()) as stream:
+            for change in stream:
+                handler(change)
 
     def next_change(self) -> SessionLifecycleEvent:
         """Pull a single lifecycle event from the stream and return it."""
-        for change in self.changes():
-            return change
-        raise RuntimeError("stream ended before receiving a session lifecycle event")
+        with closing(self.changes()) as stream:
+            for change in stream:
+                return change
+        raise MacpTransportError("stream ended before receiving a session lifecycle event")
 
 
 class PolicyWatcher:
@@ -222,23 +278,31 @@ class PolicyWatcher:
         self._client = client
         self._auth = auth
 
-    def changes(self) -> Iterator[PolicyChange]:
-        """Yield ``PolicyChange`` items from the runtime stream."""
-        for response in self._client.watch_policies(auth=self._auth):
-            descriptors = list(response.descriptors) if hasattr(response, "descriptors") else []
-            observed = getattr(response, "observed_at_unix_ms", 0)
-            yield PolicyChange(descriptors=descriptors, observed_at_unix_ms=observed)
+    def changes(self) -> Generator[PolicyChange, None, None]:
+        """Yield ``PolicyChange`` items from the runtime stream.
+
+        Wraps the inner ``watch_policies()`` generator in its own
+        ``closing()`` -- see ``SignalWatcher.signals()``'s docstring for
+        why a bare ``for`` loop here isn't enough.
+        """
+        with closing(self._client.watch_policies(auth=self._auth)) as responses:
+            for response in responses:
+                descriptors = list(response.descriptors) if hasattr(response, "descriptors") else []
+                observed = getattr(response, "observed_at_unix_ms", 0)
+                yield PolicyChange(descriptors=descriptors, observed_at_unix_ms=observed)
 
     def watch(self, handler: Callable[[PolicyChange], None]) -> None:
         """Block and invoke *handler* for each policy change."""
-        for change in self.changes():
-            handler(change)
+        with closing(self.changes()) as stream:
+            for change in stream:
+                handler(change)
 
     def next_change(self) -> PolicyChange:
         """Pull a single policy change from the stream and return it."""
-        for change in self.changes():
-            return change
-        raise RuntimeError("stream ended before receiving a policy change")
+        with closing(self.changes()) as stream:
+            for change in stream:
+                return change
+        raise MacpTransportError("stream ended before receiving a policy change")
 
 
 # ── Deprecated aliases (issue #103 / multiagentcoordinationprotocol#135) ─────

{macp_sdk_python-0.13.0.dist-info → macp_sdk_python-0.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: macp-sdk-python
-Version: 0.13.0
+Version: 0.14.0
 Summary: Python SDK for the MACP Rust runtime
 Author-email: Multi-Agent Coordination Protocol <macp@multiagentcoordinationprotocol.org>
 License: Apache-2.0

{macp_sdk_python-0.13.0.dist-info → macp_sdk_python-0.14.0.dist-info}/RECORD

@@ -1,35 +1,35 @@
-macp_sdk/__init__.py,sha256=TsUKVkKC8ShuzIKtozE9v3tS_4zAhIJ1yANLuefNHB4,9314
+macp_sdk/__init__.py,sha256=3_jOyxk5PLEqR8thQ-6wnlG7UNjdtsx6c_x8yUplxRI,9464
 macp_sdk/_logging.py,sha256=pHxyG89c9b_r8mcVSBA4E3e1GMAI5Jcc4_jslzKO6fM,431
-macp_sdk/auth.py,sha256=ouqQW7P7LqUn6_0OilqDBmsrW1IrPQNJ-ofe1La2iqw,2856
+macp_sdk/auth.py,sha256=3476zrbbMYGBlofUszljP4Yl0-0rFzBOqvIQk6fhOcY,2900
 macp_sdk/base_projection.py,sha256=5wIPPb8YTmSSuZlvSI8WuezArLELQE-Xz2GVAQtRXEk,21344
 macp_sdk/base_session.py,sha256=RCpLdSNLm3Voj1KCH__pTPbsQL2Xm4Q1zp3mp3UDE1o,8730
-macp_sdk/client.py,sha256=AplJy86LNTKBQWX2OOAO7jUTq3Isp97DkFCUxVOPYs4,43987
+macp_sdk/client.py,sha256=FUxn4Gtsq6VdfANt4TF18t1BXQzaFzaAg-8XGGsgQN4,45274
 macp_sdk/commitment_hash.py,sha256=TO5H3IQdYOCVXRvv6dxOed0D9qV6fAe3zadOjbqQ1bI,14709
 macp_sdk/constants.py,sha256=7BaQC6qycmPEc1ChOQVDxlhEBsBdI-RQBT07BQ2Uiis,481
 macp_sdk/decision.py,sha256=8yU5bv-DUU7eWgioc9CYVSB1sPcO9essiy-jsDQEunc,4792
-macp_sdk/envelope.py,sha256=_MlJ43Dih3_FcJ4hyrirFqrOvb5RaK9ssQo9Y3kMlF0,9200
+macp_sdk/envelope.py,sha256=P19YlSURfqPRkt1pt0HqZQlgf5-GC1yRc2coSyeK-hg,9103
 macp_sdk/errors.py,sha256=19dutKnnl-jtMOWpNBl2UEMCH_Sunz84G05G-wr7w1k,3836
-macp_sdk/handoff.py,sha256=EEyQkG-TeTF3p09Lotnzm5kPQ-fpIYxWk9jt5VnoCv8,12775
+macp_sdk/handoff.py,sha256=mqvvu5PMAatuf-iiXfhNCSaVJvuNk05PcswSTcnBPJs,12783
 macp_sdk/policy.py,sha256=MoyQ9l7zI0vkz_4Ewg8RRr-4DUhFBVPDQ-tn0r94sVw,19815
-macp_sdk/projections.py,sha256=tH2kt3HydaJsewhoavV7unydH-ulkOm5COo9RC3QHj0,7483
+macp_sdk/projections.py,sha256=gbapgUgdw9PxNURWNBGI2ARuLVxf_sOhQZx6CWlGDKM,10025
 macp_sdk/proposal.py,sha256=DneQzr8bBOCue5zhJ7ZP_s5kVxcUgRrk8au_GHeOrgg,15326
 macp_sdk/proto_registry.py,sha256=jgGKE4maGbTejVhYotHFdUnN_ZjZgEqsDWpU8Hh1mN8,17628
 macp_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-macp_sdk/quorum.py,sha256=_LYkbQWqbOHCt-ojgarWPcvdGm-7aB0ZMMKOfxXgUlE,10927
+macp_sdk/quorum.py,sha256=_u-f2fjPXEALMlboOrBcXbMkUveTdNxJ4BZgq3LZblo,12184
 macp_sdk/retry.py,sha256=KgRGC4Raz5Yto_LoRoPApmeERdTMP6fBQcQRpX_-w6g,1866
-macp_sdk/task.py,sha256=plfuF9f8krKnbbNA8NxkM61jX6PbRLHLWtSYEMKjSIY,19946
-macp_sdk/validation.py,sha256=nJUKx9hhrFtCIACe_TAzmzStloPCHYu8WGPXknPwAcE,8752
-macp_sdk/watchers.py,sha256=r0RayslkAKbwEI7ubfbnm_4eNq0HnUpWJugnDAsmfMM,9976
+macp_sdk/task.py,sha256=SYZLOqDkTxCT3YvQDdJp0y1raSy8e2PRzt0H1Aj8l48,21264
+macp_sdk/validation.py,sha256=Rb7ZBOI4n0DVZtdRkzT6l3BCZ9owzOSJTpsYlpHhwBI,10335
+macp_sdk/watchers.py,sha256=lfklb1CAxYq2PkCPXOdp4vT4y5QKazFZacpajKEvTmQ,13121
 macp_sdk/agent/__init__.py,sha256=vrwgt4vaBGom2m45cm39GOTZ5QLya-h1f4IGKihLsTc,3673
 macp_sdk/agent/cancel_callback.py,sha256=fCbAZ2LlmPtbNz_B6zn_be-m-g4CsKQLE_5x674KNzE,5541
 macp_sdk/agent/dispatcher.py,sha256=t1wLYGpqJdm2nIaaEVStp_8zUIetHL8FT2wYNniLDTA,3972
-macp_sdk/agent/participant.py,sha256=iC6I9gtdDuE_4o2G4nmVV0EjbIa8rZthnBkQ14XZ1E0,25738
-macp_sdk/agent/runner.py,sha256=jFZNVPm4tPuY_yDEsiFFB_FpaX5nMG6__L6xwuo52A8,9013
-macp_sdk/agent/strategies.py,sha256=8o55FR5a-L2TCX2nCw8L8PO-ucswHniR2m8qVmuP4V0,14665
+macp_sdk/agent/participant.py,sha256=1j_AFN-7X8bMwbkheSlbUo895zRZJEVPkNJS4gTpnE4,30307
+macp_sdk/agent/runner.py,sha256=OFsePj7rIeAEr_jQFlyFJV13MFF1zJ_6b12xGZ4DV1A,10371
+macp_sdk/agent/strategies.py,sha256=RPz-lpVsjFMrzN6-L7_MoMoeHR-PGhLqq4kP036mdo0,16452
 macp_sdk/agent/transports.py,sha256=xKM_cC2Qy3-PwktlZZMcTnbIwGKiXa3PvZmRQXXPDHo,14731
 macp_sdk/agent/types.py,sha256=wtlF-tTRGnEGHhYknhu-5ZzOBZ1pRQ5GjYLKBR4YzQg,1610
-macp_sdk_python-0.13.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-macp_sdk_python-0.13.0.dist-info/METADATA,sha256=iwAFkfL0b0X0QmI6rfYBdH1tdixtal3TWPUowelAWjI,7478
-macp_sdk_python-0.13.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-macp_sdk_python-0.13.0.dist-info/top_level.txt,sha256=AoSstnUrSaVCCQw4KLxLkpO-9BLoVZ230mPBR6z-jh8,9
-macp_sdk_python-0.13.0.dist-info/RECORD,,
+macp_sdk_python-0.14.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+macp_sdk_python-0.14.0.dist-info/METADATA,sha256=FojmVwT6W5G2TeDaXUxZ2Ulv4qC1QGfWhjOZaEsKGFk,7478
+macp_sdk_python-0.14.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+macp_sdk_python-0.14.0.dist-info/top_level.txt,sha256=AoSstnUrSaVCCQw4KLxLkpO-9BLoVZ230mPBR6z-jh8,9
+macp_sdk_python-0.14.0.dist-info/RECORD,,