humanrpc 0.1.0__py3-none-any.whl

humanrpc/__init__.py

@@ -0,0 +1,8 @@
+from humanrpc.client.client import HumanRPCClient
+
+Client = HumanRPCClient
+
+__all__ = [
+    "Client",
+    "HumanRPCClient",
+]

humanrpc/__main__.py

@@ -0,0 +1,145 @@
+import json
+from pathlib import Path
+from importlib.resources import files
+
+import httpx
+import typer
+import uvicorn
+
+from rich import print
+from rich.table import Table
+
+from humanrpc.server.app import create_app
+
+cli = typer.Typer(help="HumanRPC CLI")
+
+inspect_cli = typer.Typer(help="Inspect server state")
+respond_cli = typer.Typer(help="Manually respond to requests")
+
+cli.add_typer(inspect_cli, name="inspect")
+cli.add_typer(respond_cli, name="respond")
+
+
+@cli.command()
+def serve(
+    host: str = "127.0.0.1",
+    port: int = 1078,
+    no_static: bool = False,
+):
+    app = create_app(
+        serve_static=not no_static,
+    )
+
+    uvicorn.run(
+        app,
+        host=host,
+        port=port,
+        reload=False,
+    )
+
+
+@cli.command("static-path")
+def static_path():
+    path = files("humanrpc").joinpath("static")
+    print(Path(path))
+
+
+@inspect_cli.command("endpoints")
+def inspect_endpoints(
+    endpoint: str = "http://127.0.0.1:1078",
+):
+    r = httpx.get(f"{endpoint}/endpoints")
+    data = r.json()
+
+    table = Table(title="Registered Endpoints")
+    table.add_column("Name")
+
+    for name in data.keys():
+        table.add_row(name)
+
+    print(table)
+
+
+@inspect_cli.command("request")
+def inspect_request(
+    request_id: str,
+    endpoint: str = "http://127.0.0.1:1078",
+):
+    r = httpx.get(f"{endpoint}/requests/{request_id}")
+    data = r.json()
+
+    print(data)
+
+
+@inspect_cli.command("pending")
+def inspect_pending(
+    endpoint: str = "http://127.0.0.1:1078",
+):
+    r = httpx.get(f"{endpoint}/requests/pending")
+    data = r.json()
+
+    print(data)
+
+
+@respond_cli.command("success")
+def respond_success(
+    request_id: str,
+    payload: str,
+    endpoint: str = "http://127.0.0.1:1078",
+):
+    data = json.loads(payload)
+
+    httpx.post(
+        f"{endpoint}/respond/success/{request_id}",
+        json=data,
+    )
+
+    print("[green]Response sent (success)[/green]")
+
+
+@respond_cli.command("exception")
+def respond_exception(
+    request_id: str,
+    exception_type: str,
+    payload: str,
+    endpoint: str = "http://127.0.0.1:1078",
+):
+    data = json.loads(payload)
+
+    httpx.post(
+        f"{endpoint}/respond/exception/{request_id}",
+        params={"exception_type": exception_type},
+        json=data,
+    )
+
+    print(
+        f"[yellow]Response sent (exception: {exception_type})[/yellow]"
+    )
+
+
+@respond_cli.command("timeout")
+def respond_timeout(
+    request_id: str,
+    endpoint: str = "http://127.0.0.1:1078",
+):
+    httpx.post(f"{endpoint}/respond/timeout/{request_id}")
+
+    print("[blue]Response sent (timeout)[/blue]")
+
+
+@respond_cli.command("ignore")
+def respond_ignore(
+    request_id: str,
+    endpoint: str = "http://127.0.0.1:1078",
+):
+    httpx.post(f"{endpoint}/respond/ignore/{request_id}")
+
+    print("[dim]Response sent (ignore)[/dim]")
+
+
+def main():
+    cli()
+
+
+if __name__ == "__main__":
+    main()

humanrpc/client/client.py

@@ -0,0 +1,46 @@
+import httpx
+
+from humanrpc.client.endpoint import Endpoint
+from humanrpc.models.endpoint import (
+    EndpointDefinition,
+    ExceptionDefinition,
+)
+
+
+class HumanRPCClient:
+    def __init__(self, base_url: str = "http://127.0.0.1:1078"):
+        self.base_url = base_url
+
+    def endpoint(
+        self,
+        *,
+        name: str,
+        input_model,
+        response_model,
+        exceptions=None,
+    ) -> Endpoint:
+        exceptions = exceptions or []
+
+        definition = EndpointDefinition(
+            name=name,
+            input_schema=input_model.model_json_schema(),
+            response_schema=response_model.model_json_schema(),
+            exceptions=[
+                ExceptionDefinition(name=exc.__name__)
+                for exc in exceptions
+            ],
+        )
+
+        httpx.post(
+            f"{self.base_url}/endpoints",
+            json=definition.model_dump(),
+            timeout=5.0,
+        )
+
+        return Endpoint(
+            name=name,
+            input_model=input_model,
+            response_model=response_model,
+            exceptions=exceptions,
+            base_url=self.base_url,
+        )

humanrpc/client/endpoint.py

@@ -0,0 +1,119 @@
+import uuid
+import httpx
+import asyncio
+import json
+import time
+import websockets
+
+from pydantic import BaseModel
+
+
+class Endpoint:
+    def __init__(
+        self,
+        *,
+        name: str,
+        input_model,
+        response_model,
+        exceptions: list[type[Exception]],
+        base_url: str,
+    ):
+        self.name = name
+        self.input_model = input_model
+        self.response_model = response_model
+        self.exceptions = exceptions
+        self.base_url = base_url
+
+    async def aask(self, request: BaseModel):
+        payload = request.model_dump()
+        request_id = str(uuid.uuid4())
+
+        # Use AsyncClient to avoid blocking the loop
+        async with httpx.AsyncClient() as client:
+            await client.post(
+                f"{self.base_url}/requests",
+                json={
+                    "request_id": request_id,
+                    "endpoint_name": self.name,
+                    "payload": payload,
+                },
+                timeout=5.0,
+            )
+
+        ws_url = self.base_url.replace("http", "ws")
+        ws_url = f"{ws_url}/ws/requests/{request_id}"
+
+        async with websockets.connect(ws_url) as ws:
+            await ws.send("ready")
+
+            while True:
+                msg = await ws.recv()
+                record = json.loads(msg)
+
+                response = record.get("response")
+                if not response:
+                    continue
+
+                kind = response.get("kind")
+
+                if kind == "success":
+                    return self.response_model.model_validate(response["payload"])
+
+                if kind == "exception":
+                    exc_type = response["exception_type"]
+
+                    for exc in self.exceptions:
+                        if exc.__name__ == exc_type:
+                            raise exc(**response["payload"])
+
+                    raise Exception(f"Unknown exception: {exc_type}")
+
+                if kind == "timeout":
+                    raise TimeoutError()
+
+                if kind == "ignore":
+                    return None
+
+    def ask(self, request: BaseModel):
+        request_id = str(uuid.uuid4())
+        
+        with httpx.Client() as client:
+            client.post(
+                f"{self.base_url}/requests",
+                json={
+                    "request_id": request_id,
+                    "endpoint_name": self.name,
+                    "payload": request.model_dump(),
+                },
+                timeout=5.0,
+            )
+
+            # Poll for resolution
+            while True:
+                r = client.get(f"{self.base_url}/requests/{request_id}")
+                if r.status_code == 200:
+                    record = r.json()
+                    if record.get("status") == "completed":
+                        response = record.get("response")
+                        if not response:
+                            raise Exception("Request completed with no response payload.")
+
+                        kind = response.get("kind")
+
+                        if kind == "success":
+                            return self.response_model.model_validate(response["payload"])
+
+                        if kind == "exception":
+                            exc_type = response["exception_type"]
+                            for exc in self.exceptions:
+                                if exc.__name__ == exc_type:
+                                    raise exc(**response["payload"])
+                            raise Exception(f"Unknown exception: {exc_type}")
+
+                        if kind == "timeout":
+                            raise TimeoutError()
+
+                        if kind == "ignore":
+                            return None
+
+                time.sleep(0.2)

humanrpc/models/endpoint.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel, Field
+
+
+class ExceptionDefinition(BaseModel):
+    name: str
+
+
+class EndpointDefinition(BaseModel):
+    name: str
+
+    input_schema: dict
+    response_schema: dict
+
+    exceptions: list[ExceptionDefinition] = Field(default_factory=list)

humanrpc/models/request.py

@@ -0,0 +1,13 @@
+from uuid import uuid4
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+
+class RequestEnvelope(BaseModel):
+    request_id: str = Field(default_factory=lambda: str(uuid4()))
+
+    endpoint_name: str
+
+    payload: dict
+
+    created_at: datetime = Field(default_factory=datetime.utcnow)

humanrpc/models/response.py

@@ -0,0 +1,33 @@
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class SuccessResponse(BaseModel):
+    kind: Literal["success"] = "success"
+
+    payload: dict
+
+
+class ExceptionResponse(BaseModel):
+    kind: Literal["exception"] = "exception"
+
+    exception_type: str
+
+    payload: dict
+
+
+class TimeoutResponse(BaseModel):
+    kind: Literal["timeout"] = "timeout"
+
+
+class IgnoreResponse(BaseModel):
+    kind: Literal["ignore"] = "ignore"
+
+ResponseEnvelope = (
+    SuccessResponse
+    | ExceptionResponse
+    | TimeoutResponse
+    | IgnoreResponse
+)
+

humanrpc/server/app.py

@@ -0,0 +1,37 @@
+from importlib.resources import files
+
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+
+from starlette.routing import Mount
+
+from humanrpc.server.routes import router as core_router
+from humanrpc.server.manual import router as manual_router
+from humanrpc.server.ws import router as ws_router
+
+
+def create_app(*, serve_static: bool = True) -> FastAPI:
+    app = FastAPI()
+
+    app.include_router(ws_router)
+    app.include_router(core_router)
+    app.include_router(manual_router)
+
+    if serve_static:
+        static_dir = files("humanrpc").joinpath("static")
+
+        app.mount(
+            "/",
+            StaticFiles(
+                directory=str(static_dir),
+                html=True,
+            ),
+            name="static",
+        )
+
+    return app
+
+
+app = create_app()
+
+app.routes.sort(key=lambda r: 1 if isinstance(r, Mount) and r.path == "/" else 0)

humanrpc/server/manual.py

@@ -0,0 +1,71 @@
+from datetime import datetime
+from fastapi import APIRouter
+
+from humanrpc.server.state import state
+from humanrpc.models.response import (
+    SuccessResponse,
+    ExceptionResponse,
+    TimeoutResponse,
+    IgnoreResponse,
+)
+
+router = APIRouter()
+
+
+async def _complete(request_id: str):
+    await state.notify(request_id)
+
+
+@router.post("/respond/success/{request_id}")
+async def respond_success(request_id: str, payload: dict):
+    record = state.requests.get(request_id)
+
+    if record:
+        record.status = "completed"
+        record.response = SuccessResponse(payload=payload)
+        record.responded_at = datetime.utcnow()
+        await _complete(request_id)
+
+    return {"ok": True}
+
+
+@router.post("/respond/exception/{request_id}")
+async def respond_exception(request_id: str, exception_type: str, payload: dict):
+    record = state.requests.get(request_id)
+
+    if record:
+        record.status = "completed"
+        record.response = ExceptionResponse(
+            exception_type=exception_type,
+            payload=payload,
+        )
+        record.responded_at = datetime.utcnow()
+        await _complete(request_id)
+
+    return {"ok": True}
+
+
+@router.post("/respond/timeout/{request_id}")
+async def respond_timeout(request_id: str):
+    record = state.requests.get(request_id)
+
+    if record:
+        record.status = "completed"
+        record.response = TimeoutResponse()
+        record.responded_at = datetime.utcnow()
+        await _complete(request_id)
+
+    return {"ok": True}
+
+
+@router.post("/respond/ignore/{request_id}")
+async def respond_ignore(request_id: str):
+    record = state.requests.get(request_id)
+
+    if record:
+        record.status = "completed"
+        record.response = IgnoreResponse()
+        record.responded_at = datetime.utcnow()
+        await _complete(request_id)
+
+    return {"ok": True}

humanrpc/server/routes.py

@@ -0,0 +1,110 @@
+from datetime import datetime
+from fastapi import APIRouter, HTTPException
+from fastapi.encoders import jsonable_encoder
+from humanrpc.models.endpoint import EndpointDefinition
+from humanrpc.models.request import RequestEnvelope
+from humanrpc.server.state import state, RequestRecord
+from humanrpc.models.response import (
+    SuccessResponse,
+    ExceptionResponse,
+    TimeoutResponse,
+    IgnoreResponse,
+)
+
+router = APIRouter()
+
+
+@router.post("/endpoints")
+async def register_endpoint(endpoint: EndpointDefinition):
+    state.endpoints[endpoint.name] = endpoint
+    return {"status": "ok"}
+
+
+@router.get("/endpoints")
+async def list_endpoints():
+    return state.endpoints
+
+
+@router.post("/requests")
+async def submit_request(request: RequestEnvelope):
+    if request.endpoint_name not in state.endpoints:
+        raise HTTPException(status_code=404, detail="Unknown endpoint")
+
+    state.requests[request.request_id] = RequestRecord(request=request)
+
+    return {"status": "queued", "request_id": request.request_id}
+
+
+@router.get("/requests/pending")
+async def list_pending():
+    return jsonable_encoder([
+        r.model_dump(mode="json")
+        for r in state.requests.values()
+        if r.status == "pending"
+    ])
+
+
+@router.get("/requests")
+async def list_requests():
+    return jsonable_encoder([
+        r.model_dump(mode="json")
+        for r in state.requests.values()
+    ])
+
+
+@router.get("/requests/{request_id}")
+async def get_request(request_id: str):
+    record = state.requests.get(request_id)
+
+    if not record:
+        raise HTTPException(status_code=404, detail="Not found")
+
+    # IMPORTANT: JSON-safe (fixes datetime crash)
+    return jsonable_encoder(record.model_dump(mode="json"))
+
+
+@router.post("/requests/{request_id}/resolve")
+@router.post("/api/requests/{request_id}/resolve")
+async def resolve_request(request_id: str, data: dict):
+    record = state.requests.get(request_id)
+    if not record:
+        raise HTTPException(status_code=404, detail="Not found")
+
+    status = data.get("status", "completed")
+    response = data.get("response")
+
+    # Record status must be "completed" for client to stop waiting
+    record.status = "completed"
+
+    # Map frontend status to the correct ResponseEnvelope
+    if status == "rejected":
+        record.response = ExceptionResponse(
+            exception_type="Exception",
+            payload={"message": "Rejected by human operator"}
+        )
+    else:
+        # Ensure we construct the proper ResponseEnvelope subclass
+        if isinstance(response, dict) and "kind" in response:
+            kind = response.get("kind")
+            if kind == "success":
+                record.response = SuccessResponse(payload=response.get("payload", {}))
+            elif kind == "exception":
+                record.response = ExceptionResponse(
+                    exception_type=response.get("exception_type", "Exception"),
+                    payload=response.get("payload", {})
+                )
+            elif kind == "timeout":
+                record.response = TimeoutResponse()
+            elif kind == "ignore":
+                record.response = IgnoreResponse()
+            else:
+                record.response = SuccessResponse(payload=response)
+        else:
+            record.response = SuccessResponse(payload=response)
+
+    record.responded_at = datetime.utcnow()
+    
+    # Notify all listeners (including client polling/WebSockets)
+    await state.notify(request_id)
+    
+    return {"status": "ok"}

humanrpc/server/state.py

@@ -0,0 +1,52 @@
+from datetime import datetime
+from typing import Literal, Callable, Awaitable
+from pydantic import BaseModel
+
+from humanrpc.models.endpoint import EndpointDefinition
+from humanrpc.models.request import RequestEnvelope
+from humanrpc.models.response import ResponseEnvelope
+
+
+class RequestRecord(BaseModel):
+    request: RequestEnvelope
+    status: Literal["pending", "completed"] = "pending"
+    response: ResponseEnvelope | None = None
+    responded_at: datetime | None = None
+
+
+Listener = Callable[[RequestRecord], Awaitable[None]]
+
+
+class State:
+    def __init__(self):
+        self.endpoints: dict[str, EndpointDefinition] = {}
+        self.requests: dict[str, RequestRecord] = {}
+        self.listeners: dict[str, list[Listener]] = {}
+
+    def add_listener(self, request_id: str, cb: Listener):
+        self.listeners.setdefault(request_id, []).append(cb)
+
+    def remove_listener(self, request_id: str, cb: Listener):
+        if request_id in self.listeners:
+            try:
+                self.listeners[request_id].remove(cb)
+            except ValueError:
+                pass
+            if not self.listeners[request_id]:
+                self.listeners.pop(request_id, None)
+
+    def remove_listeners(self, request_id: str):
+        self.listeners.pop(request_id, None)
+
+    async def notify(self, request_id: str):
+        record = self.requests.get(request_id)
+        if not record:
+            return
+
+        for cb in list(self.listeners.get(request_id, [])):
+            try:
+                await cb(record)
+            except Exception:
+                pass
+
+state = State()

humanrpc/server/ws.py

@@ -0,0 +1,252 @@
+import asyncio
+from datetime import datetime
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+
+from humanrpc.server.state import state
+from humanrpc.models.response import (
+    SuccessResponse,
+    ExceptionResponse,
+    TimeoutResponse,
+    IgnoreResponse,
+)
+
+router = APIRouter()
+
+# Keep track of active browser console dashboard WebSocket connections
+active_consoles = set()
+
+
+class ObservableDict(dict):
+    """
+    A dictionary wrapper that executes a callback whenever a key-value 
+    pair is added or updated, enabling automatic live notifications.
+    """
+    def __init__(self, initial_dict, on_set=None):
+        super().__init__(initial_dict)
+        self._on_set = on_set
+
+    def __setitem__(self, key, value):
+        is_new = key not in self
+        super().__setitem__(key, value)
+        if self._on_set:
+            self._on_set(key, value, is_new)
+
+
+def broadcast_to_consoles(message):
+    """Safely dispatches a JSON message to all open console dashboards."""
+    async def send_all():
+        for ws in list(active_consoles):
+            try:
+                await ws.send_json(message)
+            except Exception:
+                active_consoles.discard(ws)
+                
+    try:
+        loop = asyncio.get_running_loop()
+        if loop.is_running():
+            loop.create_task(send_all())
+    except RuntimeError:
+        pass
+
+
+def get_all_endpoints():
+    """Helper to cleanly serialize registered schemas from state."""
+    endpoints = []
+    if hasattr(state, "endpoints"):
+        raw = state.endpoints.values() if isinstance(state.endpoints, dict) else state.endpoints
+        for e in raw:
+            if hasattr(e, "model_dump"):
+                endpoints.append(e.model_dump(mode="json"))
+            else:
+                endpoints.append(e)
+    return endpoints
+
+
+def get_all_requests():
+    """Helper to cleanly serialize active/historical requests from state."""
+    requests = []
+    for r in state.requests.values():
+        if hasattr(r, "model_dump"):
+            requests.append(r.model_dump(mode="json"))
+        else:
+            requests.append(r)
+    return requests
+
+
+def on_request_set(request_id, record, is_new):
+    """Triggered automatically whenever a request is registered or modified."""
+    event_type = "request_created" if is_new else "request_updated"
+    
+    # Notify all consoles about the request change
+    broadcast_to_consoles({
+        "type": event_type,
+        "request": record.model_dump(mode="json") if hasattr(record, "model_dump") else record
+    })
+    
+    # If a new request is created, hook a listener to propagate updates
+    if is_new:
+        async def listener(rec):
+            broadcast_to_consoles({
+                "type": "request_updated",
+                "request": rec.model_dump(mode="json") if hasattr(rec, "model_dump") else rec
+            })
+        try:
+            state.add_listener(request_id, listener)
+        except Exception:
+            pass
+
+
+# 1. Bind listeners for any pre-existing requests on server startup
+for req_id, rec in list(state.requests.items()):
+    async def legacy_listener(r):
+        broadcast_to_consoles({
+            "type": "request_updated",
+            "request": r.model_dump(mode="json") if hasattr(r, "model_dump") else r
+        })
+    try:
+        state.add_listener(req_id, legacy_listener)
+    except Exception:
+        pass
+
+# 2. Patch the requests dictionary to automatically observe future updates
+state.requests = ObservableDict(state.requests, on_set=on_request_set)
+
+# 3. Patch the endpoints collection (if dict/list) to notify consoles on updates
+if hasattr(state, "endpoints"):
+    if isinstance(state.endpoints, dict):
+        def on_endpoint_set(key, val, is_new):
+            broadcast_to_consoles({
+                "type": "init",
+                "endpoints": get_all_endpoints(),
+                "requests": get_all_requests()
+            })
+        state.endpoints = ObservableDict(state.endpoints, on_set=on_endpoint_set)
+    elif isinstance(state.endpoints, list):
+        original_append = state.endpoints.append
+        def patched_append(item):
+            original_append(item)
+            broadcast_to_consoles({
+                "type": "init",
+                "endpoints": get_all_endpoints(),
+                "requests": get_all_requests()
+            })
+        state.endpoints.append = patched_append
+
+
+# --- 1. Global Console Dashboard WebSocket Endpoint ---
+@router.websocket("/ws")
+async def ws_console(websocket: WebSocket):
+    """
+    Acts as the main real-time bridge for the browser dashboard.
+    Loads initial data on load, and listens for client updates.
+    """
+    await websocket.accept()
+    active_consoles.add(websocket)
+    
+    try:
+        # Load active dataset
+        await websocket.send_json({
+            "type": "init",
+            "endpoints": get_all_endpoints(),
+            "requests": get_all_requests()
+        })
+        
+        while True:
+            # Optionally receive human actions (e.g., resolutions over WebSockets)
+            data = await websocket.receive_json()
+            if data.get("type") in ("resolve", "respond"):
+                request_id = data.get("id") or data.get("request_id")
+                response = data.get("response")
+                status = data.get("status", "completed")
+                
+                if request_id:
+                    record = state.requests.get(request_id)
+                    if record:
+                        # Record status must be "completed" so that the waiting client resumes
+                        record.status = "completed"
+                        
+                        # Set proper ResponseEnvelope subclass values
+                        if status == "rejected":
+                            record.response = ExceptionResponse(
+                                exception_type="Exception",
+                                payload={"message": "Rejected by human operator"}
+                            )
+                        else:
+                            if isinstance(response, dict) and "kind" in response:
+                                kind = response.get("kind")
+                                if kind == "success":
+                                    record.response = SuccessResponse(payload=response.get("payload", {}))
+                                elif kind == "exception":
+                                    record.response = ExceptionResponse(
+                                        exception_type=response.get("exception_type", "Exception"),
+                                        payload=response.get("payload", {})
+                                    )
+                                elif kind == "timeout":
+                                    record.response = TimeoutResponse()
+                                elif kind == "ignore":
+                                    record.response = IgnoreResponse()
+                                else:
+                                    record.response = SuccessResponse(payload=response)
+                            else:
+                                record.response = SuccessResponse(payload=response)
+                        
+                        record.responded_at = datetime.utcnow()
+                        
+                        # Correctly dispatch notifications to registered listeners
+                        await state.notify(request_id)
+    except WebSocketDisconnect:
+        pass
+    finally:
+        active_consoles.discard(websocket)
+
+
+# --- 2. Client-Specific Blocking WebSocket Endpoint ---
+@router.websocket("/ws/requests/{request_id}")
+async def ws_request(request_id: str, websocket: WebSocket):
+    """Matches standard client await loops."""
+    await websocket.accept()
+
+    record = state.requests.get(request_id)
+    if record and record.status == "completed":
+        await websocket.send_json(record.model_dump(mode="json"))
+        await websocket.close()
+        return
+
+    stop_event = asyncio.Event()
+
+    async def listener(rec):
+        try:
+            await websocket.send_json(rec.model_dump(mode="json"))
+            if rec.status == "completed":
+                stop_event.set()
+        except Exception:
+            stop_event.set()
+
+    state.add_listener(request_id, listener)
+
+    if record:
+        try:
+            await websocket.send_json(record.model_dump(mode="json"))
+        except Exception:
+            stop_event.set()
+
+    async def receive_loop():
+        try:
+            while not stop_event.is_set():
+                await websocket.receive_text()
+        except WebSocketDisconnect:
+            pass
+        finally:
+            stop_event.set()
+
+    receive_task = asyncio.create_task(receive_loop())
+
+    try:
+        await stop_event.wait()
+    finally:
+        state.remove_listener(request_id, listener)
+        receive_task.cancel()
+        try:
+            await websocket.close()
+        except Exception:
+            pass

humanrpc-0.1.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: humanrpc
+Version: 0.1.0
+Summary: Human-powered typed RPC endpoints for building systems before the real implementation exists.
+Author: cvaz1306
+Author-email: christophervaz160@gmail.com
+Requires-Python: >=3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: fastapi (>=0.136.3,<0.137.0)
+Requires-Dist: httpx (>=0.28.1,<0.29.0)
+Requires-Dist: pydantic (>=2.13.4,<3.0.0)
+Requires-Dist: rich (>=15.0.0,<16.0.0)
+Requires-Dist: typer (>=0.26.6,<0.27.0)
+Requires-Dist: uvicorn (>=0.48.0,<0.49.0)
+Requires-Dist: websockets (>=16.0,<17.0)
+Description-Content-Type: text/markdown
+
+# HumanRPC
+
+HumanRPC is a human-powered RPC server for developing distributed systems before the real implementation exists.
+
+Instead of calling an AI agent, microservice, planner, or capability, your application calls a typed endpoint. A human operator receives the request in a web UI, provides a response, and HumanRPC returns the result to the caller.
+
+The goal is to enable rapid development of orchestration, routing, scheduling, memory, and workflow systems without waiting for every component to be implemented.
+
+## Features
+
+* Pydantic-first API
+* Typed request and response models
+* Async and sync clients
+* Human-powered endpoint implementations
+* Exception simulation
+* Timeout simulation
+* Web UI for handling requests
+* No external infrastructure required
+
+## Example
+
+```python
+from humanrpc import Client
+
+client = Client()
+
+agent = client.endpoint(
+    name="agent",
+    input_model=ChatRequest,
+    response_model=ChatResponse,
+    exceptions=[
+        ValueError,
+        HTTPException,
+    ],
+)
+
+result = await agent.aask(
+    ChatRequest(...)
+)
+```
+
+## Status
+
+Early development.
+
+

humanrpc-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+humanrpc/__init__.py,sha256=_AP5_HdH1yieYH5fIZhc1KV54i35x6Vjw3iNBBY-wJY,134
+humanrpc/__main__.py,sha256=a2i2DGMG7NDhn2r_sdFAE5Ly61GHw5VJhOywzRFn5Ss,3011
+humanrpc/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+humanrpc/client/client.py,sha256=-5PY0OcfwlAIe3K6xchjC6dpgmqkoeHdCXuRUj_uT_g,1188
+humanrpc/client/endpoint.py,sha256=oXaP4Nybc9DxulDF5zeCAQ6_mD0Rd2bM-FhETyzZPJg,3873
+humanrpc/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+humanrpc/models/endpoint.py,sha256=HW6jNe_w8OCnyc7d5Qrh2Z6oZEnfnNRNdtff34znyik,282
+humanrpc/models/request.py,sha256=ElcQ7lH3uM5mQkUO4SMHMLhylg_mCkzlqzp0pn5G5pk,316
+humanrpc/models/response.py,sha256=ZtJbbwtaknwjebSZnuj1sGZCqI1qmMsDF45AgCKZ8qI,578
+humanrpc/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+humanrpc/server/app.py,sha256=MmWHf75Iu7n-Yk8IdukGQwHjsW0Nx8HY4CMc-4PVWj4,925
+humanrpc/server/manual.py,sha256=cm6CY8FjV3HpyRWoHalLOviFHQQzuPsqmfEDrzqMXuw,1909
+humanrpc/server/routes.py,sha256=XV_C_C3TA2cbeK5VQUT_jfhonmJNrVIp520xQiS4oY0,3601
+humanrpc/server/state.py,sha256=1YBN8s2eN0s2O2oIjF1lxQhqKMOrvv-c-s90kwvx1ug,1648
+humanrpc/server/ws.py,sha256=0nbDwaPeQq_SIv3W9QtDPIUWnh4BuagBmgJvesRBbs4,9216
+humanrpc-0.1.0.dist-info/entry_points.txt,sha256=d6pWmG3REfFpvuQRMQHPDsODi8GwiCvLQQYF7120oLk,51
+humanrpc-0.1.0.dist-info/METADATA,sha256=5cHDOsUR59XTPyiersnIgJprDiez4BTU7bf6oz5Cqbw,1871
+humanrpc-0.1.0.dist-info/WHEEL,sha256=EGEvSphFYqXKs23-kQBeyNoJP1nrT8ZJKQoi5p5DYL8,88
+humanrpc-0.1.0.dist-info/RECORD,,

humanrpc-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.0
+Root-Is-Purelib: true
+Tag: py3-none-any

humanrpc-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+humanrpc=humanrpc.__main__:main
+