janus-broker 1.2.1__tar.gz

janus_broker-1.2.1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: janus-broker
+Version: 1.2.1
+Summary: Python SDK for Janus — A2A-native Durable Agent Broker
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: respx>=0.21; extra == "dev"

janus_broker-1.2.1/janus_broker/__init__.py

@@ -0,0 +1,76 @@
+from .client import JanusAPIError, JanusClient
+from .worker import JanusWorker, WorkerError, WorkerResult
+from .models import (
+    APIKey,
+    Agent,
+    AgentCapability,
+    Budget,
+    BudgetRequest,
+    BudgetSpec,
+    ContextRef,
+    CreateAPIKey,
+    CreateAPIKeyRequest,
+    CreateMailboxRequest,
+    Mailbox,
+    MailboxActionResponse,
+    PublishTaskRequest,
+    PullResult,
+    AckRequest,
+    NackRequest,
+    PolicyRule,
+    PolicyContext,
+    PolicyRuleRequest,
+    PolicyRuleTemplateRequest,
+    RetryPolicy,
+    TaskError,
+    RegisterAgentRequest,
+    RegisterAgentCapability,
+    Tenant,
+    TaskEnvelope,
+    Target,
+    Payload,
+    ToolInvocation,
+    TraceContext,
+    Task,
+    UpdateMailboxRequest,
+)
+
+__all__ = [
+    "JanusClient",
+    "JanusAPIError",
+    "JanusWorker",
+    "WorkerError",
+    "WorkerResult",
+    "APIKey",
+    "Agent",
+    "AgentCapability",
+    "Budget",
+    "BudgetRequest",
+    "BudgetSpec",
+    "ContextRef",
+    "CreateAPIKey",
+    "CreateAPIKeyRequest",
+    "CreateMailboxRequest",
+    "Mailbox",
+    "MailboxActionResponse",
+    "PublishTaskRequest",
+    "PullResult",
+    "AckRequest",
+    "NackRequest",
+    "PolicyRule",
+    "PolicyContext",
+    "PolicyRuleRequest",
+    "PolicyRuleTemplateRequest",
+    "RetryPolicy",
+    "TaskError",
+    "RegisterAgentRequest",
+    "RegisterAgentCapability",
+    "Tenant",
+    "TaskEnvelope",
+    "Target",
+    "Payload",
+    "ToolInvocation",
+    "TraceContext",
+    "Task",
+    "UpdateMailboxRequest",
+]

janus_broker-1.2.1/janus_broker/client.py

@@ -0,0 +1,263 @@
+import httpx
+from typing import Optional
+
+from .models import (
+    RegisterAgentRequest,
+    PublishTaskRequest,
+    PullResult,
+    AckRequest,
+    NackRequest,
+    Task,
+)
+
+
+class JanusAPIError(httpx.HTTPStatusError):
+    """Typed error raised when the Janus API returns a non-2xx response.
+
+    Compatible with httpx.HTTPStatusError (so existing try/except still works)
+    but also exposes the structured fields from the Janus error envelope:
+    code, message, and status.
+
+    Attributes:
+        code: Canonical error code (e.g. "NOT_FOUND", "INVALID_ARGUMENT").
+        message: Human-readable error message.
+        status: HTTP status code (int).
+    """
+
+    code: str
+    message: str
+    status: int
+
+    def __init__(self, response: httpx.Response):
+        super().__init__(response.text, request=response.request, response=response)
+        self.status = response.status_code
+        try:
+            body = response.json()
+            self.code = body.get("code", "UNKNOWN")
+            self.message = body.get("message", body.get("error", response.text))
+        except Exception:
+            self.code = "UNKNOWN"
+            self.message = response.text
+
+    def __str__(self) -> str:
+        return f"{self.code} ({self.status}): {self.message}"
+
+
+class JanusClient:
+    def __init__(
+        self,
+        base_url: str = "http://localhost:8080",
+        tenant_id: str = "default",
+        api_key: Optional[str] = None,
+        timeout: float = 30.0,
+    ):
+        self._base_url = base_url.rstrip("/")
+        self._tenant_id = tenant_id
+        headers = {}
+        if api_key:
+            headers["X-API-Key"] = api_key
+        self._client = httpx.Client(timeout=timeout, headers=headers)
+
+    def _check(self, resp: httpx.Response) -> None:
+        """Raise JanusAPIError on non-2xx responses."""
+        if resp.is_success:
+            return
+        raise JanusAPIError(resp)
+
+    @property
+    def _prefix(self) -> str:
+        return f"/v1/tenants/{self._tenant_id}"
+
+    def _url(self, path: str) -> str:
+        return f"{self._base_url}{self._prefix}{path}"
+
+    def register_agent(self, req: RegisterAgentRequest) -> None:
+        resp = self._client.post(self._url("/agents"), json=req.model_dump(exclude_none=True))
+        self._check(resp)
+
+    def publish_task(self, req: PublishTaskRequest) -> dict:
+        resp = self._client.post(self._url("/tasks"), json=req.model_dump(exclude_none=True))
+        self._check(resp)
+        return resp.json()
+
+    def get_task(self, task_id: str) -> Task:
+        resp = self._client.get(self._url(f"/tasks/{task_id}"))
+        self._check(resp)
+        return Task.model_validate(resp.json())
+
+    def pull_task(self, mailbox_id: str, agent_id: str = "default") -> Optional[PullResult]:
+        resp = self._client.post(
+            self._url(f"/mailboxes/{mailbox_id}/pull"),
+            json={"agent_id": agent_id},
+        )
+        self._check(resp)
+        if resp.status_code == 204 or not resp.content:
+            return None
+        return PullResult.model_validate(resp.json())
+
+    def start_task(self, task_id: str, lease_id: str) -> None:
+        resp = self._client.post(
+            self._url(f"/tasks/{task_id}/start"),
+            json={"lease_id": lease_id},
+        )
+        self._check(resp)
+
+    def heartbeat(self, task_id: str, lease_id: str) -> None:
+        resp = self._client.post(
+            self._url(f"/tasks/{task_id}/heartbeat"),
+            json={"lease_id": lease_id},
+        )
+        self._check(resp)
+
+    def ack_task(self, task_id: str, req: AckRequest) -> None:
+        resp = self._client.post(
+            self._url(f"/tasks/{task_id}/ack"),
+            json=req.model_dump(exclude_none=True),
+        )
+        self._check(resp)
+
+    def nack_task(self, task_id: str, req: NackRequest) -> None:
+        resp = self._client.post(
+            self._url(f"/tasks/{task_id}/nack"),
+            json=req.model_dump(exclude_none=True),
+        )
+        self._check(resp)
+
+    def cancel_task(self, task_id: str) -> None:
+        resp = self._client.post(self._url(f"/tasks/{task_id}/cancel"))
+        self._check(resp)
+
+    def get_task_events(self, task_id: str) -> list[dict]:
+        resp = self._client.get(self._url(f"/tasks/{task_id}/events"))
+        self._check(resp)
+        data = resp.json()
+        return data.get("events", data) if isinstance(data, dict) else data
+
+    def create_tenant(self, tenant_id: str, name: str) -> dict:
+        resp = self._client.post(
+            f"{self._base_url}/v1/tenants",
+            json={"id": tenant_id, "name": name},
+        )
+        self._check(resp)
+        return resp.json()
+
+    def get_tenant(self, tenant_id: str) -> dict:
+        resp = self._client.get(f"{self._base_url}/v1/tenants/{tenant_id}")
+        self._check(resp)
+        return resp.json()
+
+    def create_mailbox(self, req) -> dict:
+        resp = self._client.post(self._url("/mailboxes"), json=req.model_dump(exclude_none=True))
+        self._check(resp)
+        return resp.json()
+
+    def get_mailbox(self, mailbox_id: str) -> dict:
+        resp = self._client.get(self._url(f"/mailboxes/{mailbox_id}"))
+        self._check(resp)
+        return resp.json()
+
+    def update_mailbox(self, mailbox_id: str, req) -> dict:
+        resp = self._client.patch(self._url(f"/mailboxes/{mailbox_id}"), json=req.model_dump(exclude_none=True))
+        self._check(resp)
+        return resp.json()
+
+    def pause_mailbox(self, mailbox_id: str) -> dict:
+        resp = self._client.post(self._url(f"/mailboxes/{mailbox_id}/pause"))
+        self._check(resp)
+        return resp.json()
+
+    def resume_mailbox(self, mailbox_id: str) -> dict:
+        resp = self._client.post(self._url(f"/mailboxes/{mailbox_id}/resume"))
+        self._check(resp)
+        return resp.json()
+
+    def heartbeat_agent(self, agent_id: str) -> dict:
+        resp = self._client.post(self._url(f"/agents/{agent_id}/heartbeat"))
+        self._check(resp)
+        return resp.json()
+
+    def list_agents(self) -> list[dict]:
+        resp = self._client.get(self._url("/agents"))
+        self._check(resp)
+        return resp.json().get("agents", [])
+
+    def get_agent(self, agent_id: str) -> dict:
+        resp = self._client.get(self._url(f"/agents/{agent_id}"))
+        self._check(resp)
+        return resp.json()
+
+    def query_dlq(self, mailbox_id: str = "", limit: int = 50) -> list[dict]:
+        params = {"limit": str(limit)}
+        if mailbox_id:
+            params["mailbox"] = mailbox_id
+        resp = self._client.get(self._url("/dlq"), params=params)
+        self._check(resp)
+        return resp.json().get("tasks", [])
+
+    def replay_dlq(self, task_id: str) -> dict:
+        resp = self._client.post(self._url(f"/dlq/{task_id}/replay"))
+        self._check(resp)
+        return resp.json()
+
+    def discard_dlq(self, task_id: str) -> None:
+        resp = self._client.post(self._url(f"/dlq/{task_id}/discard"))
+        self._check(resp)
+
+    def create_api_key(self, name: str) -> dict:
+        resp = self._client.post(self._url("/api-keys"), json={"name": name})
+        self._check(resp)
+        return resp.json()
+
+    def list_api_keys(self) -> list[dict]:
+        resp = self._client.get(self._url("/api-keys"))
+        self._check(resp)
+        return resp.json().get("api_keys", [])
+
+    def revoke_api_key(self, key_id: str) -> dict:
+        resp = self._client.post(self._url(f"/api-keys/{key_id}/revoke"))
+        self._check(resp)
+        return resp.json()
+
+    def create_policy_rule(self, req) -> dict:
+        resp = self._client.post(self._url("/policy-rules"), json=req.model_dump(exclude_none=True))
+        self._check(resp)
+        return resp.json()
+
+    def create_policy_rule_from_template(self, req) -> dict:
+        resp = self._client.post(self._url("/policy-rules/templates"), json=req.model_dump(exclude_none=True))
+        self._check(resp)
+        return resp.json()
+
+    def list_policy_rules(self) -> list[dict]:
+        resp = self._client.get(self._url("/policy-rules"))
+        self._check(resp)
+        return resp.json().get("policy_rules", [])
+
+    def upsert_budget(self, req) -> dict:
+        resp = self._client.post(self._url("/budgets"), json=req.model_dump(exclude_none=True))
+        self._check(resp)
+        return resp.json()
+
+    def get_budget(self, scope_type: str, scope_id: str) -> dict:
+        resp = self._client.get(self._url(f"/budgets/{scope_type}/{scope_id}"))
+        self._check(resp)
+        return resp.json()
+
+    def list_budgets(self) -> list[dict]:
+        resp = self._client.get(self._url("/budgets"))
+        self._check(resp)
+        return resp.json().get("budgets", [])
+
+    def replay_task(self, task_id: str) -> dict:
+        resp = self._client.post(self._url(f"/tasks/{task_id}/replay"))
+        self._check(resp)
+        return resp.json()
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()

janus_broker-1.2.1/janus_broker/models.py

@@ -0,0 +1,271 @@
+from pydantic import BaseModel, Field
+from typing import Any, Optional
+from enum import Enum
+
+
+class TargetType(str, Enum):
+    AGENT = "agent"
+    MAILBOX = "mailbox"
+    SEMANTIC = "semantic"
+
+
+class Target(BaseModel):
+    type: TargetType = TargetType.AGENT
+    value: str = ""
+
+
+class Payload(BaseModel):
+    type: str = "json"
+    content: str = ""
+
+
+class TraceContext(BaseModel):
+    trace_id: str = ""
+    span_id: str = ""
+    parent_span_id: str = ""
+
+
+class TaskEnvelope(BaseModel):
+    janus_version: str = "0.1"
+    task_id: str = ""
+    tenant_id: str = ""
+    source_agent: str = ""
+    target: Target = Field(default_factory=Target)
+    priority: str = "normal"
+    payload: Payload = Field(default_factory=Payload)
+    trace: TraceContext = Field(default_factory=TraceContext)
+
+
+class Task(BaseModel):
+    id: str = ""
+    tenant_id: str = ""
+    source_agent: str = ""
+    target_type: str = ""
+    target_value: str = ""
+    mailbox_id: str = ""
+    status: str = ""
+    priority: str = ""
+    envelope: Optional[TaskEnvelope] = None
+    attempt_count: int = 0
+    created_at: str = ""
+    updated_at: str = ""
+
+
+class TaskError(BaseModel):
+    code: str = ""
+    message: str = ""
+
+
+class RegisterAgentRequest(BaseModel):
+    id: str
+    display_name: str = ""
+    protocol: str = "a2a"
+    capabilities: list[str] = Field(default_factory=list)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class PublishTaskRequest(BaseModel):
+    id: str = ""
+    source_agent: str = ""
+    target_type: str = "agent"
+    target_value: str = ""
+    mailbox_id: str = ""
+    priority: str = "normal"
+    envelope: Optional[TaskEnvelope] = None
+
+
+class LeaseInfo(BaseModel):
+    lease_id: str = ""
+    expires_at: Any = None
+
+
+class PullResult(BaseModel):
+    task: Optional[Task] = None
+    lease: LeaseInfo = Field(default_factory=LeaseInfo)
+
+
+class AckRequest(BaseModel):
+    lease_id: str = ""
+    attempt: int = 0
+    result_ref: str = ""
+    token_usage: Optional[dict[str, int]] = None
+
+
+class NackRequest(BaseModel):
+    lease_id: str = ""
+    attempt: int = 0
+    retriable: bool = False
+    error: Optional[TaskError] = None
+
+
+# --- Governance / management models ---
+
+
+class Tenant(BaseModel):
+    id: str = ""
+    name: str = ""
+
+
+class AgentCapability(BaseModel):
+    capability: str = ""
+    description: str = ""
+    capability_schema: Optional[str] = Field(None, alias="schema")
+
+    model_config = {"populate_by_name": True}
+
+
+class Agent(BaseModel):
+    id: str = ""
+    tenant_id: str = ""
+    team_id: str = ""
+    display_name: str = ""
+    protocol: str = ""
+    endpoint: str = ""
+    status: str = ""
+    description: str = ""
+    capabilities: list[AgentCapability] = []
+    max_concurrency: int = 0
+    rpm: int = 0
+    tpm: int = 0
+
+
+class RegisterAgentCapability(BaseModel):
+    capability: str = ""
+    description: str = ""
+    capability_schema: str = Field("", alias="schema")
+
+    model_config = {"populate_by_name": True}
+
+
+class Budget(BaseModel):
+    max_tokens: int = 0
+    max_cost_usd: float = 0.0
+    model_classes: list[str] = []
+
+
+class BudgetSpec(BaseModel):
+    tenant_id: str = ""
+    scope_type: str = ""
+    scope_id: str = ""
+    max_concurrency: int = 0
+    rpm: int = 0
+    tpm: int = 0
+    daily_cost_usd: float = 0.0
+    monthly_cost_usd: float = 0.0
+
+
+class BudgetRequest(BaseModel):
+    scope_type: str = ""
+    scope_id: str = ""
+    rpm: int = 0
+    tpm: int = 0
+    max_concurrency: int = 0
+    daily_cost_usd: float = 0.0
+    monthly_cost_usd: float = 0.0
+
+
+class ContextRef(BaseModel):
+    type: str = ""
+    uri: str = ""
+    hash: str = ""
+    classification: str = ""
+    access_scope: list[str] = []
+
+
+class RetryPolicy(BaseModel):
+    max_attempts: int = 0
+    backoff_type: str = ""
+    initial_seconds: int = 0
+    max_seconds: int = 0
+    jitter: bool = False
+
+
+class Mailbox(BaseModel):
+    id: str = ""
+    tenant_id: str = ""
+    agent_id: str = ""
+    status: str = ""
+    priority: str = ""
+    max_deliver: int = 0
+    retry_policy: Optional[RetryPolicy] = None
+
+
+class CreateMailboxRequest(BaseModel):
+    id: str = ""
+    agent_id: str = ""
+    max_concurrency: int = 0
+    ack_wait_seconds: int = 0
+    max_deliver: int = 0
+    retention_seconds: int = 0
+
+
+class UpdateMailboxRequest(BaseModel):
+    max_concurrency: Optional[int] = None
+    ack_wait_seconds: Optional[int] = None
+    max_deliver: Optional[int] = None
+    retention_seconds: Optional[int] = None
+    status: Optional[str] = None
+
+
+class MailboxActionResponse(BaseModel):
+    status: str = ""
+
+
+class PolicyContext(BaseModel):
+    data_classification: str = ""
+    requires_human_approval: bool = False
+    allowed_tools: list[str] = []
+
+
+class PolicyRule(BaseModel):
+    tenant_id: str = ""
+    id: str = ""
+    name: str = ""
+    status: str = ""
+    priority: int = 0
+    condition: Optional[dict] = None
+    action: Optional[dict] = None
+
+
+class PolicyRuleRequest(BaseModel):
+    name: str = ""
+    status: str = ""
+    priority: int = 0
+    condition: Optional[dict] = None
+    action: Optional[dict] = None
+
+
+class PolicyRuleTemplateRequest(BaseModel):
+    template: str = ""
+    agent_id: str = ""
+    team_id: str = ""
+    capability: str = ""
+    tool: str = ""
+    data_classification: str = ""
+    name: str = ""
+    status: str = ""
+    priority: int = 0
+
+
+class ToolInvocation(BaseModel):
+    id: str = ""
+    name: str = ""
+    namespace: str = ""
+    source_protocol: str = ""
+
+
+class CreateAPIKey(BaseModel):
+    id: str = ""
+    key: str = ""
+    name: str = ""
+
+
+class CreateAPIKeyRequest(BaseModel):
+    name: str = ""
+
+
+class APIKey(BaseModel):
+    id: str = ""
+    name: str = ""
+    prefix: str = ""
+    status: str = ""

janus_broker-1.2.1/janus_broker/worker.py

@@ -0,0 +1,125 @@
+"""JanusWorker: a high-level poll-process-ack loop for Python agents."""
+
+import logging
+import threading
+import time
+from typing import Callable, Optional
+
+from .client import JanusClient, JanusAPIError
+from .models import Task, AckRequest, NackRequest, TaskError
+
+logger = logging.getLogger("janus_broker.worker")
+
+
+class WorkerResult:
+    """Result of processing a single task."""
+
+    def __init__(self, task_id: str, success: bool, error: Optional[str] = None):
+        self.task_id = task_id
+        self.success = success
+        self.error = error
+
+
+class WorkerError(Exception):
+    """Raised when the worker encounters an unrecoverable error."""
+
+
+TaskHandler = Callable[[Task], "tuple[str, Optional[dict]]"]
+
+
+class JanusWorker:
+    """A high-level helper that runs a poll-process-ack loop.
+
+    The application provides a handler function that receives a Task and returns
+    (result_ref, token_usage). The Worker handles polling, task start/heartbeat,
+    and ACK/NACK.
+
+    Args:
+        client: A JanusClient instance.
+        agent_id: The agent ID this worker pulls for.
+        mailbox_id: The mailbox to poll.
+        poll_interval: Seconds between polls when queue is empty (default 2).
+        heartbeat_interval: Seconds between task heartbeats (default 30).
+    """
+
+    def __init__(
+        self,
+        client: JanusClient,
+        agent_id: str,
+        mailbox_id: str,
+        poll_interval: float = 2.0,
+        heartbeat_interval: float = 30.0,
+    ):
+        self._client = client
+        self._agent_id = agent_id
+        self._mailbox_id = mailbox_id
+        self._poll_interval = poll_interval
+        self._heartbeat_interval = heartbeat_interval
+        self._stop = threading.Event()
+
+    def run(self, handler: TaskHandler) -> None:
+        """Run the worker loop until stop() is called."""
+        while not self._stop.is_set():
+            try:
+                self._process_one(handler)
+            except Exception as e:
+                logger.error("janus worker: %s", e)
+
+    def stop(self) -> None:
+        """Signal the worker to stop."""
+        self._stop.set()
+
+    def _process_one(self, handler: TaskHandler) -> None:
+        result = self._client.pull_task(self._mailbox_id, self._agent_id)
+        if result is None:
+            self._stop.wait(self._poll_interval)
+            return
+
+        task = result.task
+        lease_id = result.lease.lease_id
+        attempt = result.lease.attempt
+
+        try:
+            self._client.start_task(task.id, lease_id)
+        except JanusAPIError as e:
+            raise WorkerError(f"start task {task.id}: {e}") from e
+
+        # Heartbeat in a background thread.
+        hb_stop = threading.Event()
+
+        def _heartbeat():
+            while not hb_stop.is_set() and not self._stop.is_set():
+                try:
+                    self._client.heartbeat(task.id, lease_id)
+                except Exception:
+                    pass
+                hb_stop.wait(self._heartbeat_interval)
+
+        hb_thread = threading.Thread(target=_heartbeat, daemon=True)
+        hb_thread.start()
+
+        success = False
+        error_msg = None
+        try:
+            result_ref, usage = handler(task)
+            success = True
+        except Exception as e:
+            error_msg = str(e)
+
+        hb_stop.set()
+
+        if success:
+            ack = AckRequest(lease_id=lease_id, attempt=attempt, result_ref=result_ref)
+            if usage:
+                ack.token_usage = usage
+            self._client.ack_task(task.id, ack)
+        else:
+            self._client.nack_task(
+                task.id,
+                NackRequest(
+                    lease_id=lease_id,
+                    attempt=attempt,
+                    retriable=True,
+                    error=TaskError(code="HANDLER_ERROR", message=error_msg or "unknown"),
+                ),
+            )

janus_broker-1.2.1/janus_broker.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: janus-broker
+Version: 1.2.1
+Summary: Python SDK for Janus — A2A-native Durable Agent Broker
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: respx>=0.21; extra == "dev"

janus_broker-1.2.1/janus_broker.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+pyproject.toml
+janus_broker/__init__.py
+janus_broker/client.py
+janus_broker/models.py
+janus_broker/worker.py
+janus_broker.egg-info/PKG-INFO
+janus_broker.egg-info/SOURCES.txt
+janus_broker.egg-info/dependency_links.txt
+janus_broker.egg-info/requires.txt
+janus_broker.egg-info/top_level.txt
+tests/test_client.py

janus_broker-1.2.1/janus_broker.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

janus_broker-1.2.1/janus_broker.egg-info/requires.txt

@@ -0,0 +1,7 @@
+httpx>=0.27
+pydantic>=2.0
+
+[dev]
+pytest>=8.0
+pytest-asyncio>=0.23
+respx>=0.21

janus_broker-1.2.1/janus_broker.egg-info/top_level.txt

@@ -0,0 +1 @@
+janus_broker

janus_broker-1.2.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "janus-broker"
+version = "1.2.1"
+description = "Python SDK for Janus — A2A-native Durable Agent Broker"
+requires-python = ">=3.10"
+dependencies = [
+    "httpx>=0.27",
+    "pydantic>=2.0",
+]
+
+[tool.setuptools.packages.find]
+include = ["janus_broker*"]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "respx>=0.21",
+]

janus_broker-1.2.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

janus_broker-1.2.1/tests/test_client.py

@@ -0,0 +1,161 @@
+import pytest
+import httpx
+import respx
+
+from janus_broker import (
+    JanusClient,
+    RegisterAgentRequest,
+    PublishTaskRequest,
+    PullResult,
+    AckRequest,
+    NackRequest,
+    TaskError,
+    TaskEnvelope,
+    Target,
+    Payload,
+)
+
+
+BASE = "http://localhost:8080"
+TENANT = "test-tenant"
+PREFIX = f"/v1/tenants/{TENANT}"
+
+
+@pytest.fixture
+def client():
+    with JanusClient(BASE, TENANT) as c:
+        yield c
+
+
+class TestRegisterAgent:
+    def test_success(self, client):
+        with respx.mock:
+            respx.post(f"{BASE}{PREFIX}/agents").mock(return_value=httpx.Response(201))
+            client.register_agent(RegisterAgentRequest(id="a1", display_name="Agent 1"))
+
+    def test_server_error(self, client):
+        with respx.mock:
+            respx.post(f"{BASE}{PREFIX}/agents").mock(return_value=httpx.Response(500))
+            with pytest.raises(httpx.HTTPStatusError):
+                client.register_agent(RegisterAgentRequest(id="a1", display_name="Agent 1"))
+
+
+class TestPublishTask:
+    def test_success(self, client):
+        with respx.mock:
+            respx.post(f"{BASE}{PREFIX}/tasks").mock(
+                return_value=httpx.Response(202, json={"id": "t1", "status": "queued"})
+            )
+            result = client.publish_task(PublishTaskRequest(
+                id="t1", source_agent="a1", target_value="a2",
+                envelope=TaskEnvelope(
+                    task_id="t1", tenant_id=TENANT, source_agent="a1",
+                    target=Target(value="a2"), payload=Payload(content='{"key":"val"}'),
+                ),
+            ))
+            assert result["id"] == "t1"
+
+
+class TestGetTask:
+    def test_success(self, client):
+        with respx.mock:
+            respx.get(f"{BASE}{PREFIX}/tasks/t1").mock(
+                return_value=httpx.Response(200, json={"id": "t1", "status": "running"})
+            )
+            task = client.get_task("t1")
+            assert task.id == "t1"
+            assert task.status == "running"
+
+
+class TestPullTask:
+    def test_with_task(self, client):
+        with respx.mock:
+            respx.post(f"{BASE}{PREFIX}/mailboxes/mb1/pull").mock(
+                return_value=httpx.Response(200, json={
+                    "task": {"id": "t1", "status": "pending"},
+                    "lease": {"lease_id": "l1", "expires_at": "2026-01-01T00:00:00Z"},
+                })
+            )
+            result = client.pull_task("mb1", "agent-1")
+            assert result is not None
+            assert result.task.id == "t1"
+            assert result.lease.lease_id == "l1"
+
+    def test_empty(self, client):
+        with respx.mock:
+            respx.post(f"{BASE}{PREFIX}/mailboxes/mb1/pull").mock(
+                return_value=httpx.Response(204)
+            )
+            result = client.pull_task("mb1")
+            assert result is None
+
+
+class TestAckTask:
+    def test_success(self, client):
+        with respx.mock:
+            respx.post(f"{BASE}{PREFIX}/tasks/t1/ack").mock(
+                return_value=httpx.Response(200)
+            )
+            client.ack_task("t1", AckRequest(lease_id="l1", result_ref="result://a1/t1"))
+
+
+class TestNackTask:
+    def test_with_error(self, client):
+        with respx.mock:
+            respx.post(f"{BASE}{PREFIX}/tasks/t1/nack").mock(
+                return_value=httpx.Response(200)
+            )
+            client.nack_task("t1", NackRequest(
+                lease_id="l1", retriable=True,
+                error=TaskError(code="TIMEOUT", message="timed out"),
+            ))
+
+    def test_without_error(self, client):
+        with respx.mock:
+            respx.post(f"{BASE}{PREFIX}/tasks/t1/nack").mock(
+                return_value=httpx.Response(200)
+            )
+            client.nack_task("t1", NackRequest(lease_id="l1"))
+
+
+class TestCancelTask:
+    def test_success(self, client):
+        with respx.mock:
+            respx.post(f"{BASE}{PREFIX}/tasks/t1/cancel").mock(
+                return_value=httpx.Response(200)
+            )
+            client.cancel_task("t1")
+
+
+class TestGetTaskEvents:
+    def test_success(self, client):
+        with respx.mock:
+            respx.get(f"{BASE}{PREFIX}/tasks/t1/events").mock(
+                return_value=httpx.Response(200, json={
+                    "events": [
+                        {"event_type": "task.created", "task_id": "t1"},
+                        {"event_type": "task.started", "task_id": "t1"},
+                    ]
+                })
+            )
+            events = client.get_task_events("t1")
+            assert len(events) == 2
+            assert events[0]["event_type"] == "task.created"
+
+
+class TestHeartbeat:
+    def test_success(self, client):
+        with respx.mock:
+            respx.post(f"{BASE}{PREFIX}/tasks/t1/heartbeat").mock(
+                return_value=httpx.Response(200)
+            )
+            client.heartbeat("t1", "l1")
+
+
+class TestStartTask:
+    def test_success(self, client):
+        with respx.mock:
+            respx.post(f"{BASE}{PREFIX}/tasks/t1/start").mock(
+                return_value=httpx.Response(200)
+            )
+            client.start_task("t1", "l1")