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

package/sidecars/claude/events.py

@@ -1,457 +0,0 @@
-"""Claude Agent SDK message stream -> sidecar wire events.
-
-This is the Python half of T17's message-stream mapping
-(docs/tasks/runtime/claude-adapter/tasks/T17-S01-message-stream.md and its
-parent T17-sidecar-events.md, "Отображение сообщений Claude в события"): one
-frozen table, transcribed here, plus the one policy the parent task already
-decided for a message or content-block type the table does not name.
-internal/backend/claude/events.go does the second half of the same mapping,
-wire event -> backend.Event.
-
-Two things this file must never do, both load-bearing:
-
-- build the daemon around the SDK client's single-turn convenience reader
-  (the one that stops at the first ResultMessage). That wrapper would end
-  its own read of the stream every turn, opening a window in which a
-  queued turn.started could be lost (see T17-sidecar-events.md, the section
-  on why the stream must be read one permanent way and not that one — this
-  file deliberately never spells that call's name, so the acceptance grep
-  for it stays a real check rather than one defeated by its own
-  explanation). run_stream below reads client.receive_messages() in one
-  loop that lives as long as the session.
-- re-emit assistant text or thinking from the final AssistantMessage's
-  TextBlock/ThinkingBlock. Both already left as StreamEvent deltas when
-  include_partial_messages=True (T16 sets this unconditionally); doing it
-  twice would double the visible reply and violate I11.
-
-Dispatch is by class name (type(message).__name__ / type(block).__name__),
-not isinstance against the real SDK classes: this keeps map_message testable
-against small fake objects with no claude-agent-sdk installed at all, and it
-is why sidecars/claude/tests/test_events.py's table test can run without the
-package this environment does not have.
-"""
-
-from __future__ import annotations
-
-import sys
-from dataclasses import dataclass, field
-from typing import Any
-
-from protocol import event
-
-# ---------------------------------------------------------------------------
-# IGNORED: every public SDK message type this mapping deliberately does not
-# emit an event for, each with a one-line reason (a string value the
-# completeness test reads, not a comment it cannot see). Every other member
-# of this build's Message union is handled by map_message's dispatch below
-# (SystemMessage, UserMessage, AssistantMessage, StreamEvent, ResultMessage,
-# and SDKUserMessageReplay where the installed SDK has it); this registry is
-# where a member the mapping does not want to touch records that decision
-# with its reason, instead of the coverage test just going red with no
-# explanation. Neither entry is a gap in the wire catalog that could be
-# closed here: the catalog is frozen and versioned, so adding a kind is a
-# protocol change, not a mapping change.
-# ---------------------------------------------------------------------------
-IGNORED: dict[str, str] = {
-    "ConversationResetMessage": "a mid-session transcript discard zeroes the SDK's running "
-    "total_cost_usd, but nothing in this sidecar or the adapter accumulates cost, and "
-    "session.history is served per request from get_session_messages() rather than a cache, so "
-    "there is no total to snapshot and no cache to invalidate",
-    "RateLimitEvent": "rate-limit status transitions are deliberately dropped, not uninteresting: "
-    'the frozen wire catalog has no event kind meaning "rate limit", which makes this a named '
-    "candidate for the next protocol version",
-}
-
-# Content block types the mapping table names but that never produce a
-# frame on their own. Kept as data (not bare comments) for the same
-# completeness-by-inspection reason as IGNORED, even though today nothing
-# reads this dict programmatically outside this module's own tests.
-IGNORED_CONTENT_BLOCKS: dict[str, str] = {
-    "ThinkingBlock": "thinking is already emitted via StreamEvent thinking_delta; re-emitting "
-    "it here would duplicate it the same way (I11), and unlike an assistant TextBlock there is "
-    "no boundary to draw: nothing downstream renders a thinking block as its own message",
-}
-
-# StreamEvent top-level types that are structural framing only: the
-# Anthropic streaming envelope around content, never content itself. Text
-# and thinking already arrived as content_block_delta events by the time
-# any of these six appear, so no event is a loss, not an omission.
-_IGNORED_STREAM_EVENT_TYPES = {
-    "message_start",
-    "content_block_start",
-    "content_block_stop",
-    "message_delta",
-    "message_stop",
-    "ping",
-}
-
-
-def _log_unknown(what: str, type_name: str) -> None:
-    """The one structured stderr line the policy requires for an unknown SDK
-    message type or content block type: no frame is emitted, the session is
-    not ended, and the fact is recorded once here so it is discoverable
-    without a live TUI (T17-sidecar-events.md, "Политика неизвестного типа
-    сообщения — РЕШЕНО").
-    """
-    sys.stderr.write(
-        f"claude sidecar: unknown SDK {what} type {type_name!r}; no event emitted\n"
-    )
-    sys.stderr.flush()
-
-
-@dataclass
-class StreamState:
-    """The turn-tracking state one session's persistent read loop owns.
-
-    tool_names (tool_use_id -> tool_name) is the one map I12 names by name:
-    it exists solely so tool.completed can name the tool ToolResultBlock
-    does not itself carry a name for. current_turn_id is not additional
-    "remembered" state in the I12 sense — a turn boundary is exactly the
-    read loop's own cursor position over the stream it is already
-    iterating, the same way an iterator's index is not a violation of
-    "the sidecar remembers nothing"; ResultMessage is the one place that
-    resets it, matching the frozen turn boundary
-    (docs/claude-sidecar.md, "ResultMessage — единственная граница конца
-    turn-а").
-    """
-
-    session_id: str
-    current_turn_id: str | None = None
-    tool_names: dict[str, str] = field(default_factory=dict)
-
-
-def _content_blocks(content: Any) -> list[Any]:
-    """UserMessage.content and AssistantMessage.content are `str |
-    list[ContentBlock]` in the SDK. A bare string carries no content block
-    at all; the caller treats that as "text-bearing" directly."""
-    if isinstance(content, list):
-        return content
-    return []
-
-
-def session_ready(session_id: str, native_id: str, model: str) -> dict:
-    """The session.ready frame, built for a session that has just become open
-    and ready to accept input — a successful session.start or session.resume
-    (docs/claude-sidecar.md, "session.ready": "the session is open and ready
-    to accept input").
-
-    It is emitted there and not from the SDK's `system`/`init` message,
-    which the SDK does not produce until a query is actually sent: a session
-    that is open but not yet prompted would otherwise emit nothing at all,
-    and internal/backend/claude/status.go's automaton would never report the
-    session `idle` because its `current` stays "" until this event arrives.
-
-    The three fields the caller supplies are all known at that point
-    (session.py: the Longshot-facing id and the minted native_id, plus
-    params["model"]), so none is guessed; `at` is the same _now() every other
-    event in this module uses. model may be empty when the operator pinned none; that
-    is the honest "the model this session opened with" and not a gap to fill
-    by a lookup - the field means what session.start's own result field
-    means.
-    """
-    return event(
-        "session.ready",
-        {
-            "session_id": session_id,
-            "native_id": native_id,
-            "model": model,
-            "at": _now(),
-        },
-    )
-
-
-def _map_system(message: Any, state: StreamState) -> list[dict]:
-    # No SystemMessage subtype emits a frame, `init` included, and none is a
-    # loss. For every other subtype: no row in the mapping table, and no new
-    # top-level type the completeness test would need to see named — it is
-    # still a SystemMessage. For `init`: the only two fields it could refine
-    # are native_id and model, and both are already known at session.start
-    # (the sidecar mints native_id itself, precisely because the SDK exposes
-    # none at connect) while the adapter consumes neither -
-    # internal/backend/claude/events.go builds KindSessionStarted from
-    # session_id and at alone. What is left is a second session.ready for one
-    # session, which is duplicate noise on a frozen wire catalog.
-    return []
-
-
-def begin_turn(state: StreamState, carrier: str = "") -> list[dict]:
-    """The first accepted input of a turn starts it; input arriving while a
-    turn is already active is the queued-input fold T14-S01 measures
-    (T17-sidecar-events.md, "Fold queued-ввода в текущий turn") and gets no
-    second turn.started.
-
-    This is the one place a turn id is minted (I11), and it is called from
-    two places for the same reason: this module, when a text-bearing user
-    message shows up on the stream (a replay, where one is enabled), and
-    session.py's submit path, which is where input is actually accepted on
-    this build. The SDK sends no --replay-user-messages, so the submitted
-    message is never echoed back onto the stream and the submit call is the
-    only observation of "input accepted" there is. Neither caller mints or
-    formats anything of its own: both call this and put back what it
-    returns.
-
-    carrier lands in the frame only when the caller has one, and is left
-    out of it entirely otherwise: the value is Longshot's, minted per
-    delivery and passed to input.submit, so the stream path (which observes
-    no delivery) omits it and an absent field stays the honest "unknown"
-    rather than an empty string invented to fill the shape
-    (docs/claude-sidecar.md: carrier is optional, and on turn.started empty
-    means weak FIFO correlation).
-    """
-    if state.current_turn_id is not None:
-        return []
-    import uuid as _uuid
-
-    state.current_turn_id = str(_uuid.uuid4())
-    data = {"session_id": state.session_id, "turn_id": state.current_turn_id}
-    if carrier:
-        data["carrier"] = carrier
-    data["at"] = _now()
-    return [event("turn.started", data)]
-
-
-def _map_tool_result_block(block: Any, state: StreamState) -> list[dict]:
-    tool_use_id = getattr(block, "tool_use_id", "")
-    tool_name = state.tool_names.pop(tool_use_id, "")
-    content = getattr(block, "content", None)
-    text = _stringify_tool_result(content)
-    return [
-        event(
-            "tool.completed",
-            {
-                "session_id": state.session_id,
-                "turn_id": state.current_turn_id or "",
-                "tool_id": tool_use_id,
-                "tool_name": tool_name,
-                "text": text,
-                "at": _now(),
-            },
-        )
-    ]
-
-
-def _stringify_tool_result(content: Any) -> str:
-    """ToolResultBlock.content is `str | list[dict] | None`. The wire's
-    tool.completed.text is a plain string (docs/claude-sidecar.md); this
-    joins a structured list's text parts rather than dropping them, and
-    turns None into "" rather than the literal string "None"."""
-    if content is None:
-        return ""
-    if isinstance(content, str):
-        return content
-    if isinstance(content, list):
-        parts = []
-        for part in content:
-            if isinstance(part, dict) and "text" in part:
-                parts.append(str(part["text"]))
-            else:
-                parts.append(str(part))
-        return "".join(parts)
-    return str(content)
-
-
-def _map_user(message: Any, state: StreamState) -> list[dict]:
-    content = getattr(message, "content", None)
-    if isinstance(content, str):
-        return begin_turn(state)
-
-    frames: list[dict] = []
-    saw_text = False
-    for block in _content_blocks(content):
-        name = type(block).__name__
-        if name == "ToolResultBlock":
-            frames.extend(_map_tool_result_block(block, state))
-        elif name == "TextBlock":
-            saw_text = True
-        else:
-            _log_unknown("content block", name)
-    if saw_text:
-        # A text block precedes any tool-result frames in wire order,
-        # matching turn.started's place at the head of the turn (T15,
-        # "Порядок событий").
-        frames = begin_turn(state) + frames
-    return frames
-
-
-def _map_assistant(message: Any, state: StreamState) -> list[dict]:
-    frames: list[dict] = []
-    for block in _content_blocks(getattr(message, "content", None)):
-        name = type(block).__name__
-        if name == "TextBlock":
-            # The message boundary, which the delta stream does not carry:
-            # text_delta frames say what arrived, never that a message ended,
-            # so without this every message of a turn is one unbroken run and
-            # a transcript glues them into one paragraph (protocol 2,
-            # known-issues OI-20).
-            #
-            # The text travels with the boundary rather than being left to
-            # the deltas already sent. That is not the duplication this
-            # mapping used to avoid: it is the authoritative copy a dropped
-            # delta cannot corrupt, and it is what Codex's own
-            # item/agentMessage/completed carries, so both backends hand a
-            # front end the same fact in the same shape.
-            frames.append(
-                event(
-                    "message.completed",
-                    {
-                        "session_id": state.session_id,
-                        "turn_id": state.current_turn_id or "",
-                        "text": getattr(block, "text", "") or "",
-                        "at": _now(),
-                    },
-                )
-            )
-        elif name == "ToolUseBlock":
-            tool_id = getattr(block, "id", "")
-            tool_name = getattr(block, "name", "")
-            state.tool_names[tool_id] = tool_name
-            frames.append(
-                event(
-                    "tool.started",
-                    {
-                        "session_id": state.session_id,
-                        "turn_id": state.current_turn_id or "",
-                        "tool_id": tool_id,
-                        "tool_name": tool_name,
-                        "at": _now(),
-                    },
-                )
-            )
-        elif name in IGNORED_CONTENT_BLOCKS:
-            continue
-        else:
-            _log_unknown("content block", name)
-    return frames
-
-
-def _map_stream_event(message: Any, state: StreamState) -> list[dict]:
-    raw = getattr(message, "event", None) or {}
-    event_type = raw.get("type")
-    if event_type != "content_block_delta":
-        if event_type not in _IGNORED_STREAM_EVENT_TYPES:
-            _log_unknown("StreamEvent", str(event_type))
-        return []
-
-    delta = raw.get("delta") or {}
-    delta_type = delta.get("type")
-    if delta_type == "text_delta":
-        return [
-            event(
-                "message.delta",
-                {
-                    "session_id": state.session_id,
-                    "turn_id": state.current_turn_id or "",
-                    "delta": delta.get("text", ""),
-                    "at": _now(),
-                },
-            )
-        ]
-    if delta_type == "thinking_delta":
-        return [
-            event(
-                "thinking.delta",
-                {
-                    "session_id": state.session_id,
-                    "turn_id": state.current_turn_id or "",
-                    "delta": delta.get("thinking", ""),
-                    "at": _now(),
-                },
-            )
-        ]
-    # Any other delta.type (e.g. input_json_delta, streaming a tool call's
-    # arguments) carries no text or thinking of its own: the tool call
-    # itself is observed whole from the final AssistantMessage's
-    # ToolUseBlock, so there is nothing here to lose silently.
-    return []
-
-
-def _map_result(message: Any, state: StreamState) -> list[dict]:
-    turn_id = state.current_turn_id or ""
-    frames: list[dict] = []
-    if getattr(message, "is_error", False):
-        text = (
-            getattr(message, "result", None)
-            or getattr(message, "subtype", "")
-            or "the turn ended with an error"
-        )
-        frames.append(
-            event(
-                "error",
-                {
-                    "session_id": state.session_id,
-                    "turn_id": turn_id,
-                    "message": text,
-                    "will_retry": False,
-                    "at": _now(),
-                },
-            )
-        )
-    frames.append(
-        event(
-            "turn.completed",
-            {"session_id": state.session_id, "turn_id": turn_id, "at": _now()},
-        )
-    )
-    # ResultMessage is the one and only turn boundary (docs/claude-sidecar.md);
-    # T22's history grouping must use the same one.
-    state.current_turn_id = None
-    return frames
-
-
-# _DISPATCH maps an SDK message's class name to its handler. SDKUserMessageReplay
-# shares UserMessage's handler: both are "the first accepted input of a turn"
-# per the mapping table, and neither carries a shape this module needs to
-# tell apart from the other's.
-_DISPATCH = {
-    "SystemMessage": _map_system,
-    "UserMessage": _map_user,
-    "SDKUserMessageReplay": _map_user,
-    "AssistantMessage": _map_assistant,
-    "StreamEvent": _map_stream_event,
-    "ResultMessage": _map_result,
-}
-
-
-def map_message(message: Any, state: StreamState) -> list[dict]:
-    """Maps one Claude Agent SDK message onto zero, one or more wire event
-    frames, per the table this module transcribes. Never raises on a
-    message type or content block type it does not recognise: the policy
-    is silence-on-the-wire plus one stderr line, not a session-ending
-    exception.
-    """
-    name = type(message).__name__
-    handler = _DISPATCH.get(name)
-    if handler is None:
-        if name not in IGNORED:
-            _log_unknown("message", name)
-        return []
-    return handler(message, state)
-
-
-def _now() -> str:
-    from datetime import datetime, timezone
-
-    return datetime.now(timezone.utc).isoformat()
-
-
-async def run_stream(client: Any, state: StreamState, emit) -> None:
-    """The one permanent read loop for this session's stream: it lives as
-    long as the session and is cancelled, not exhausted, when the session
-    closes (session.py owns the one start/stop point, per T17-S01's
-    allowed zone). emit(frame) is the caller's way of putting a frame on
-    the wire; this module does not know or care how.
-
-    The loop shape is exactly the one T17-sidecar-events.md freezes and
-    forbids replacing:
-
-        async for message in client.receive_messages():
-            for frame in map_message(message):
-                await codec.write(frame)
-
-    The single-turn convenience reader this loop deliberately avoids (see
-    the module docstring) must never appear anywhere in this package; this
-    loop is the one and only reader of the stream.
-    """
-    async for message in client.receive_messages():
-        for frame in map_message(message, state):
-            emit(frame)

package/sidecars/claude/history.py

@@ -1,133 +0,0 @@
-"""Claude Agent SDK persisted session messages -> session.history wire items.
-
-This is the Python half of T22-S01's turn-grouping slice: it turns the
-objects `get_session_messages()` returns into the raw item dicts
-session.history's `items` carries on the wire (docs/claude-sidecar.md,
-"session.history"). internal/backend/claude/history.go does the grouping,
-directly off the shape serialize_message returns here.
-
-Dispatch is by class name (type(message).__name__ / type(block).__name__),
-not isinstance against the real SDK classes, for the same reason as
-events.py: this keeps serialize_message testable against small fake objects
-with no claude-agent-sdk installed at all (sidecars/claude/tests/test_history.py).
-
-This module does not group messages into turns, does not assign a turn
-status and does not rename an item type into something the Go side's
-mapping table owns: session.history's contract is "sidecar reports content,
-adapter decides meaning" (I12). Serializing an SDK object's fields into a
-JSON-safe dict is not an exception to that rule — it is the minimum a wire
-protocol needs to carry the same content at all.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-
-def _content_blocks(content: Any) -> list[Any] | None:
-    """UserMessage.content / AssistantMessage.content is `str |
-    list[ContentBlock]` in the SDK. Returns None for a bare string, so the
-    caller can carry a plain string through unchanged."""
-    if isinstance(content, list):
-        return content
-    return None
-
-
-def _serialize_block(block: Any) -> dict:
-    name = type(block).__name__
-    if name == "TextBlock":
-        return {"type": "text", "text": getattr(block, "text", "")}
-    if name == "ToolUseBlock":
-        return {
-            "type": "tool_use",
-            "id": getattr(block, "id", ""),
-            "name": getattr(block, "name", ""),
-            "input": getattr(block, "input", None) or {},
-        }
-    if name == "ToolResultBlock":
-        return {
-            "type": "tool_result",
-            "tool_use_id": getattr(block, "tool_use_id", ""),
-            "content": getattr(block, "content", None),
-            "is_error": bool(getattr(block, "is_error", False)),
-        }
-    if name == "ThinkingBlock":
-        return {"type": "thinking", "text": getattr(block, "thinking", "")}
-    # A content block type this build has never seen: carried through by its
-    # own class name rather than dropped. internal/backend/claude/history.go
-    # treats an unrecognised block type as "no item for it", never as a
-    # silent loss, and names it in the T22 report; inventing a shape for it
-    # here would hide that from the Go side instead of reporting it.
-    return {"type": name}
-
-
-def _serialize_content(content: Any) -> Any:
-    blocks = _content_blocks(content)
-    if blocks is None:
-        return content
-    return [_serialize_block(b) for b in blocks]
-
-
-def _serialize_user(message: Any) -> dict:
-    return {
-        "type": "user",
-        "uuid": getattr(message, "uuid", "") or "",
-        "message": {
-            "role": "user",
-            "content": _serialize_content(getattr(message, "content", None)),
-        },
-    }
-
-
-def _serialize_assistant(message: Any) -> dict:
-    return {
-        "type": "assistant",
-        "uuid": getattr(message, "uuid", "") or "",
-        "message": {
-            "role": "assistant",
-            "content": _serialize_content(getattr(message, "content", None)),
-        },
-    }
-
-
-def _serialize_system(message: Any) -> dict:
-    # A SystemMessage (session init and similar) carries no turn boundary and
-    # no history item on the Go side: history.go's grouping skips a message
-    # type it does not recognise as a turn participant. Serialized anyway,
-    # uuid included when present, so nothing silently vanishes from the page.
-    return {"type": "system", "uuid": getattr(message, "uuid", "") or ""}
-
-
-def _serialize_result(message: Any) -> dict:
-    return {
-        "type": "result",
-        "uuid": getattr(message, "uuid", "") or "",
-        "is_error": bool(getattr(message, "is_error", False)),
-        "subtype": getattr(message, "subtype", "") or "",
-    }
-
-
-# _DISPATCH maps a persisted SDK message's class name to its serializer.
-# SDKUserMessageReplay shares UserMessage's: measured-constraints.md section 2
-# found no distinct queued_command/SDKUserMessageReplay shape on the wire, and
-# a persisted transcript has no replay markers at all.
-_DISPATCH = {
-    "UserMessage": _serialize_user,
-    "SDKUserMessageReplay": _serialize_user,
-    "AssistantMessage": _serialize_assistant,
-    "SystemMessage": _serialize_system,
-    "ResultMessage": _serialize_result,
-}
-
-
-def serialize_message(message: Any) -> dict:
-    """Serializes one persisted SDK message object into the raw item dict
-    session.history's `items` carries. A message type this mapping has never
-    seen is carried through by its class name rather than dropped, matching
-    events.py's own unknown-type policy (minus the stderr line: this is a
-    request/response call, not a running stream to log against)."""
-    name = type(message).__name__
-    handler = _DISPATCH.get(name)
-    if handler is not None:
-        return handler(message)
-    return {"type": name}