@longshot-harness/longshot-linux-x64 0.1.0-beta.1 → 0.1.0-beta.2

package/sidecars/claude/protocol.py

@@ -1,217 +0,0 @@
-"""The sidecar wire protocol: envelope, NDJSON framing and correlation.
-
-This is the Python half of the contract frozen in
-internal/backend/claude/protocol.go and documented in full in
-docs/claude-sidecar.md. It defines the shape of a frame, and — at the
-bottom of this file — the one request/response correlation registry every
-request this side initiates goes through. The hello gate and the op
-dispatcher live in main.py.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-from collections.abc import Callable
-
-# 2 adds one event, message.completed: the doc's bump rule is that adding a
-# message bumps, because an unknown event kind is refused rather than ignored
-# (docs/claude-sidecar.md, "Versioning and the handshake").
-PROTOCOL_VERSION: int = 2
-
-
-class FrameError(Exception):
-    """Raised by read_frame for a line that is not a well-formed frame.
-
-    Never raised for EOF — that is read_frame returning None, the one
-    unconditional exit signal main.py's loop acts on.
-    """
-
-
-class Code:
-    """Refusal codes, verbatim from protocol.go's Code registry."""
-
-    HELLO_REQUIRED = "helloRequired"
-    UNSUPPORTED_VERSION = "unsupportedVersion"
-    MALFORMED_REQUEST = "malformedRequest"
-    UNKNOWN_OPERATION = "unknownOperation"
-    UNKNOWN_SESSION = "unknownSession"
-    NO_ACTIVE_TURN = "noActiveTurn"
-    UNSUPPORTED_MODE = "unsupportedMode"
-    FORBIDDEN_VALUE = "forbiddenValue"
-    INTERNAL = "internal"
-
-
-class Op:
-    """Operations Longshot may send, verbatim from protocol.go's HostOps.
-
-    tool.call and permission.request are the sidecar's own two
-    sidecar-to-Longshot requests (protocol.go's SidecarOps); they are not
-    listed here because main.py's dispatcher only classifies frames arriving
-    *from* Longshot.
-    """
-
-    HELLO = "hello"
-    SESSION_START = "session.start"
-    SESSION_RESUME = "session.resume"
-    SESSION_READ = "session.read"
-    SESSION_HISTORY = "session.history"
-    INPUT_SUBMIT = "input.submit"
-    TURN_INTERRUPT = "turn.interrupt"
-    MODEL_SET = "model.set"
-    PERMISSION_SET = "permission.set"
-    SESSION_CLOSE = "session.close"
-
-    KNOWN = frozenset(
-        (
-            HELLO,
-            SESSION_START,
-            SESSION_RESUME,
-            SESSION_READ,
-            SESSION_HISTORY,
-            INPUT_SUBMIT,
-            TURN_INTERRUPT,
-            MODEL_SET,
-            PERMISSION_SET,
-            SESSION_CLOSE,
-        )
-    )
-
-
-def read_frame(stream) -> dict | None:
-    """Read one NDJSON frame from stream, or None on EOF.
-
-    A line that is not valid JSON, or that decodes to something other than a
-    JSON object, raises FrameError rather than being skipped: skipping an
-    unrecognised line would let the second half of a split frame pass as
-    valid (docs/claude-sidecar.md, "Framing").
-    """
-    line = stream.readline()
-    if line == "":
-        return None
-    try:
-        frame = json.loads(line)
-    except ValueError as exc:
-        raise FrameError(f"the line did not parse as JSON: {exc}") from exc
-    if not isinstance(frame, dict):
-        raise FrameError("the line did not decode to a JSON object")
-    return frame
-
-
-def write_frame(stream, frame: dict) -> None:
-    """Write one frame as a single compact, newline-terminated JSON line.
-
-    separators=(",", ":") and ensure_ascii=False match the Go encoder in
-    codec.go: payloads carry prompts and diffs whose non-ASCII characters
-    must round-trip verbatim, and every frame is exactly one line.
-    """
-    stream.write(json.dumps(frame, separators=(",", ":"), ensure_ascii=False))
-    stream.write("\n")
-    stream.flush()
-
-
-def response(frame_id: int, result: dict) -> dict:
-    """Build a success response. result is never omitted: an empty result is
-    {}, matching NewResponse's rule on the Go side."""
-    return {
-        "kind": "response",
-        "id": frame_id,
-        "result": result if result is not None else {},
-    }
-
-
-def refusal(frame_id: int, code: str, message: str) -> dict:
-    """Build a refusal response. message is a whole sentence."""
-    return {
-        "kind": "response",
-        "id": frame_id,
-        "error": {"code": code, "message": message},
-    }
-
-
-def event(name: str, data: dict) -> dict:
-    """Build an event frame. Has no id: docs/claude-sidecar.md, "Envelope"."""
-    return {"kind": "event", "event": name, "data": data if data is not None else {}}
-
-
-# ---- Sidecar to Longshot: request/response correlation.
-#
-# Both requests this side initiates - permission.request (T21) and tool.call
-# (T20) - share one id counter, one pending registry and one resolve(), and
-# that sharing is the whole reason the primitive sits here instead of in
-# either caller: T20-S02 refused a second correlation mechanism outright
-# ("второго механизма корреляции здесь не появляется"), and two counters or
-# two registries would be exactly that. main.py's kind:"response" route
-# calls resolve() once, for both.
-#
-# The counter is this side's own: each side of the channel numbers its own
-# requests, unique as (initiator, id) (docs/claude-sidecar.md, "Correlation
-# and identifiers"), so nothing here ever reads or reuses a Longshot request
-# id.
-
-Emit = Callable[[dict], None]
-
-_pending: dict[int, asyncio.Future[dict]] = {}
-_next_id = 0
-
-
-def _mint_id() -> int:
-    global _next_id
-    _next_id += 1
-    return _next_id
-
-
-def resolve(frame: dict) -> bool:
-    """Routes one incoming kind:response frame to whichever sidecar-initiated
-    request is waiting on its id. Returns False when nobody is waiting: the
-    id belongs to something else, or the waiter already gave up (the pending
-    entry is removed the moment request() returns, win or lose)."""
-    future = _pending.get(frame.get("id"))
-    if future is None or future.done():
-        return False
-    error = frame.get("error")
-    if error is not None:
-        future.set_exception(RuntimeError(error.get("message", "")))
-    else:
-        future.set_result(frame.get("result") or {})
-    return True
-
-
-async def request(emit: Emit, op: str, params: dict) -> dict:
-    """Sends one sidecar-initiated request and awaits its correlated result.
-
-    There is no deadline, and none is added here: the protocol freezes
-    "there is no protocol-level timeout on either" of the two sidecar
-    requests (docs/claude-sidecar.md, "Sidecar to Longshot: requests"), and
-    each is already bounded by the peer - permission.request waits for an
-    operator, which is work rather than a hang, and tool.call is answered by
-    tools.Dispatcher, which bounds every call at
-    tools.DefaultDispatchTimeout and never fails to answer
-    (internal/tools/dispatcher.go). The bound this side does keep is channel
-    life: fail_pending below resolves everything still outstanding when the
-    session goes away, so no waiter outlives the channel it is waiting on.
-    """
-    frame_id = _mint_id()
-    future: asyncio.Future[dict] = asyncio.get_event_loop().create_future()
-    _pending[frame_id] = future
-    try:
-        emit({"kind": "request", "id": frame_id, "op": op, "params": params})
-        return await future
-    finally:
-        _pending.pop(frame_id, None)
-
-
-def fail_pending(reason: str) -> None:
-    """Fails every request still outstanding, with reason as the message.
-
-    Called when the channel this side is waiting on goes away
-    (session.disconnect, which session.close and main.py's EOF path both
-    reach unconditionally). A waiter that outlived its channel would wait
-    forever, and for tool.call that means a turn that never ends; raising
-    instead reaches the model as a readable tool result, because the SDK
-    turns a handler exception into an isError result rather than a protocol
-    error (claude_agent_sdk's create_sdk_mcp_server, run_tool).
-    """
-    for future in list(_pending.values()):
-        if not future.done():
-            future.set_exception(RuntimeError(reason))

package/sidecars/claude/pyproject.toml

@@ -1,21 +0,0 @@
-# Lint and format configuration for the Claude sidecar. The sidecar is the
-# only Python in this repository, so the configuration lives next to it
-# rather than at the repository root, which is Go.
-#
-#   ruff check sidecars/claude --fix
-#   black sidecars/claude
-
-[tool.black]
-line-length = 88
-target-version = ["py310"]
-
-[tool.ruff]
-line-length = 88
-# The floor the sidecar README states: Python 3.10+.
-target-version = "py310"
-
-[tool.ruff.lint]
-select = ["E", "W", "F", "I", "B", "UP", "SIM", "C4", "RET"]
-# black owns line length; E501 would only duplicate it and disagree at the
-# margins black deliberately leaves long (URLs, long string literals).
-ignore = ["E501"]