polyforge-v3 3.0.16__py3-none-any.whl

polyforge_v3/__init__.py

@@ -0,0 +1,4 @@
+"""polyforge-v3 — single MCP server + scenario via entry_points。
+v3-design.md §3 / §4。
+"""
+__version__ = "3.0.1"

polyforge_v3/aihub/__init__.py

@@ -0,0 +1,5 @@
+"""polyforge_v3.aihub — AihubClient, ProtocolAdapter, and model definitions."""
+from .adapter import AihubClientProtocolAdapter
+from .client import AihubClient
+
+__all__ = ["AihubClient", "AihubClientProtocolAdapter"]

polyforge_v3/aihub/_bearer.py

@@ -0,0 +1,20 @@
+"""Per-request bearer token override via ContextVar.
+
+Placed in `polyforge_v3.aihub` (not `server`) so `client.py` can import it
+without creating a circular dependency. Both `server/__main__.py` (writer)
+and `aihub/client.py` (reader) import from here.
+"""
+from __future__ import annotations
+
+from contextvars import ContextVar
+
+# Set to a non-None bearer string before an aihub client call to override the
+# default Authorization header for that request.  Reset to None (via
+# ContextVar.reset) after the call returns.  Thread / task safe because
+# ContextVar is per-asyncio-Task.
+_CURRENT_BEARER: ContextVar[str | None] = ContextVar("_current_bearer", default=None)
+
+
+def get_current_bearer() -> str | None:
+    """Return the active per-request bearer override, or None."""
+    return _CURRENT_BEARER.get()

polyforge_v3/aihub/adapter.py

@@ -0,0 +1,302 @@
+"""ProtocolAdapter — bridges AihubClient (Pydantic models) to the dict-based Protocol
+that 1C composite tools expect.
+
+design.md §10.1: 1C tools type the client by Protocol (kwargs-in / dict-out). 1B's
+concrete AihubClient takes Pydantic request objects and returns Pydantic response objects.
+This adapter wraps the concrete client, handles the Pydantic⟷dict translation, and stores
+an optional AttemptCredential for mutating endpoints.
+
+Usage::
+
+    from polyforge_v3.aihub.adapter import AihubClientProtocolAdapter
+    from polyforge_v3.aihub.client import AihubClient
+
+    concrete = AihubClient(cfg, session)
+    adapter = AihubClientProtocolAdapter(concrete)
+    adapter.set_cred(AttemptCredential(attempt_id=..., claim_epoch=..., session_secret=...))
+
+    # Now use adapter wherever 1C expects the AihubClient Protocol:
+    result = await adapter.create_work_item(project="marketplace", goal="fix x", ...)
+"""
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING, Any
+
+from .client import AihubClient
+
+if TYPE_CHECKING:
+    # Runtime-lazy: at module load time `polyforge_v3.auth` is mid-loading
+    # (auth.py:18 triggers aihub/__init__ → this module → here). Top-level
+    # `from ..auth import AttemptCredential` would race auth's own class
+    # definition. PEP 563 annotations only need the symbol for typing tools.
+    from ..auth import AttemptCredential  # noqa: F401
+from .models import (
+    ClaimRequest,
+    CompleteAttemptRequest,
+    CompleteWorkItemRequest,
+    CreateWorkItemRequest,
+    DeclaredResource,
+    EmitEventRequest,
+    PauseAttemptRequest,
+    PredictConflictsRequest,
+    RenewLeaseRequest,
+    UpdateWorkItemRequest,
+    _LockSpec,
+    _SessionInfoFrag,
+)
+
+
+class AihubClientProtocolAdapter:
+    """Wrap the concrete AihubClient to satisfy 1C's kwargs-in / dict-out Protocol.
+
+    Maintains a stored AttemptCredential (set via set_cred() after claim) for
+    mutating endpoints that require it. Some 1C calls supply credentials as kwargs
+    directly; kwargs always override the stored credential.
+
+    Lifted from the wire e2e test (test_3stream_wire_e2e.py) into production so
+    the real server.py can use it when wiring 1B to 1C.
+
+    Finding 3 fix: the test had a local ProtocolAdapter; this is its canonical home.
+    """
+
+    def __init__(self, concrete: AihubClient) -> None:
+        self._c = concrete
+        self._cred: AttemptCredential | None = None
+
+    def set_cred(self, cred: AttemptCredential) -> None:
+        """Store AttemptCredential after claim so mutating endpoints can use it."""
+        self._cred = cred
+
+    # ------------------------------------------------------------------
+    # Work items
+    # ------------------------------------------------------------------
+
+    async def create_work_item(
+        self,
+        *,
+        project: str | None,
+        goal: str,
+        scenario: str,
+        declared_resources: list[dict[str, Any]],
+        labels: list[str] | None = None,
+        priority: str = "normal",
+        external_share_type: str | None = None,
+        external_share_key: str | None = None,
+        parent_work_item_id: str | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        req = CreateWorkItemRequest(
+            project=project or "",
+            scenario=scenario,
+            goal=goal,
+            declared_resources=[
+                DeclaredResource.model_validate(r) for r in (declared_resources or [])
+            ],
+            labels=labels,
+            priority=priority,
+            external_share_type=external_share_type,
+            external_share_key=external_share_key,
+            parent_work_item_id=parent_work_item_id,
+            metadata=metadata,
+        )
+        wi = await self._c.create_work_item(req)
+        return {"work_item_id": wi.id, **wi.model_dump()}
+
+    async def predict_conflicts(
+        self,
+        *,
+        work_item_id: str | None,
+        declared_resources: list[dict[str, Any]],
+        project: str | None = None,
+    ) -> dict[str, Any]:
+        if project is not None:
+            # Prefer the explicit project kwarg (canonical path)
+            effective_project = project
+        else:
+            # Fall back to URI parsing (deprecated — callers should pass project= explicitly)
+            warnings.warn(
+                "predict_conflicts: project derivation from URI deprecated; pass project= explicitly",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            effective_project = "marketplace"
+            for r in declared_resources:
+                uri = r.get("uri", "")
+                if uri.startswith("repo:"):
+                    effective_project = uri.removeprefix("repo:")
+                    break
+        req = PredictConflictsRequest(
+            project=effective_project,
+            work_item_id=work_item_id,
+            declared_resources=[
+                DeclaredResource.model_validate(r) for r in (declared_resources or [])
+            ],
+        )
+        resp = await self._c.predict_conflicts(req)
+        return {
+            "severity": resp.severity,
+            "predictions": [p.model_dump() for p in resp.predictions],
+        }
+
+    async def claim_work_item(
+        self,
+        *,
+        work_item_id: str,
+        idempotency_key: str,
+        session_info: dict[str, Any],
+        requested_locks: list[dict[str, Any]],
+    ) -> dict[str, Any]:
+        # session_secret: prefer session_info kwarg, fall back to client session
+        secret = (
+            session_info.get("session_secret")
+            or self._c.session.session_secret
+        )
+        machine_id = session_info.get("machine_id") or self._c.session.machine_id
+        req = ClaimRequest(
+            idempotency_key=idempotency_key,
+            session_info=_SessionInfoFrag(
+                machine_id=machine_id,
+                session_secret=secret,
+            ),
+            requested_locks=[_LockSpec.model_validate(l) for l in requested_locks],
+        )
+        resp = await self._c.claim_work_item(work_item_id, req)
+        return {
+            "attempt_id": resp.attempt_id,
+            "claim_epoch": resp.claim_epoch,
+            "lease_until": resp.lease_until
+            if isinstance(resp.lease_until, str)
+            else str(resp.lease_until),
+            "session_secret": secret,
+            "machine_id": machine_id,
+        }
+
+    async def get_work_item(self, *, work_item_id: str) -> dict[str, Any]:
+        resp = await self._c.get_work_item(work_item_id)
+        return resp.model_dump(mode="json")
+
+    async def update_work_item(
+        self, *, work_item_id: str, patch_payload: dict[str, Any]
+    ) -> dict[str, Any]:
+        if self._cred is None:
+            raise RuntimeError(
+                "update_work_item requires AttemptCredential; call set_cred() first"
+            )
+        req = UpdateWorkItemRequest(
+            attempt_id=self._cred.attempt_id,
+            claim_epoch=self._cred.claim_epoch,
+            session_secret=self._cred.session_secret,
+            patch_payload=patch_payload,
+        )
+        wi = await self._c.update_work_item(work_item_id, req)
+        return {"work_item": wi.model_dump(mode="json")}
+
+    # ------------------------------------------------------------------
+    # Events
+    # ------------------------------------------------------------------
+
+    async def emit_event(
+        self,
+        *,
+        work_item_id: str,
+        event_type: str,
+        payload: dict[str, Any],
+        attempt_id: str | None = None,
+        claim_epoch: int | None = None,
+        session_secret: str | None = None,
+        pinned: bool = False,
+    ) -> dict[str, Any]:
+        """Emit an attempt-scoped event (requires AttemptCredential in body).
+
+        attempt_id, claim_epoch, session_secret may be passed as kwargs (1C pattern)
+        or resolved from the stored credential. If attempt_id is None the call raises
+        ValueError — ensure claim_work_item is called first to obtain AttemptCredential.
+        """
+        eff_attempt_id = attempt_id
+        eff_claim_epoch = claim_epoch
+        eff_session_secret = session_secret
+        # Fall back to stored cred if kwargs not provided
+        if (eff_attempt_id is None or eff_claim_epoch is None or eff_session_secret is None) and self._cred is not None:
+            eff_attempt_id = eff_attempt_id or self._cred.attempt_id
+            eff_claim_epoch = eff_claim_epoch if eff_claim_epoch is not None else self._cred.claim_epoch
+            eff_session_secret = eff_session_secret or self._cred.session_secret
+        if eff_attempt_id is None:
+            raise ValueError(
+                "emit_event requires attempt_id; no credential set. "
+                "Call claim_work_item first to obtain AttemptCredential."
+            )
+        req = EmitEventRequest(
+            attempt_id=eff_attempt_id,
+            claim_epoch=eff_claim_epoch,
+            session_secret=eff_session_secret,
+            work_item_id=work_item_id,
+            event_type=event_type,
+            payload=payload,
+            pinned=pinned,
+        )
+        resp = await self._c.emit_event(req)
+        return {"event_id": resp.event_id}
+
+    # ------------------------------------------------------------------
+    # Attempts
+    # ------------------------------------------------------------------
+
+    async def complete_attempt(
+        self,
+        *,
+        attempt_id: str,
+        claim_epoch: int,
+        session_secret: str,
+        status: str,
+    ) -> dict[str, Any]:
+        req = CompleteAttemptRequest(
+            attempt_id=attempt_id,
+            claim_epoch=claim_epoch,
+            session_secret=session_secret,
+            status=status,
+        )
+        resp = await self._c.complete_attempt(attempt_id, req)
+        return {"ok": resp.ok}
+
+    async def pause_attempt(
+        self, *, attempt_id: str, claim_epoch: int,
+        session_secret: str, reason: str,
+    ) -> dict[str, Any]:
+        req = PauseAttemptRequest(
+            attempt_id=attempt_id,
+            claim_epoch=claim_epoch,
+            session_secret=session_secret,
+            reason=reason,
+        )
+        resp = await self._c.pause_attempt(attempt_id, req)
+        return {"ok": resp.ok}
+
+    async def renew_lease(
+        self, *, attempt_id: str, claim_epoch: int, session_secret: str
+    ) -> dict[str, Any]:
+        resp = await self._c.renew_lease(
+            attempt_id, RenewLeaseRequest(claim_epoch=claim_epoch, session_secret=session_secret)
+        )
+        lu = resp.lease_until
+        return {"lease_until": lu if isinstance(lu, str) else str(lu)}
+
+    async def whoami(self) -> dict[str, Any]:
+        """Caller identity for admin-gated scenarios (release etc.)."""
+        resp = await self._c.whoami()
+        return resp.model_dump()
+
+    async def reconcile_artifacts(self, *, work_item_id: str) -> list[dict[str, Any]]:
+        """Fail-loud: composite tools must call reconcile directly, not via this adapter.
+
+        design §10.1 (B6): composite tools should call
+        polyforge_v3_coding.artifacts.reconcile directly (async). This adapter has
+        no implementation by design — calling it indicates a caller bug.
+        """
+        raise NotImplementedError(
+            "composite tools should call polyforge_v3_coding.artifacts.reconcile "
+            "directly (async); adapter has no impl by design"
+        )
+
+
+__all__ = ["AihubClientProtocolAdapter"]