harness-sdk-python 0.1.0__py3-none-any.whl

harness_sdk/__init__.py

@@ -0,0 +1,3 @@
+from .run_manager import RunManager
+
+__all__ = ["RunManager"]

harness_sdk/run_manager.py

@@ -0,0 +1,626 @@
+"""RunManager: the harness-sdk runs subsystem over a Statewire host.
+
+Implements the full state x command matrix from runs.mdx on a single
+``start(ctx)`` executor entrypoint, per the RunManager design (d4987).
+"""
+
+import asyncio
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable, Iterable
+
+from statewire import CommandExecution, StatewireClientHandle, StatewireReject
+from statewire.state import plain
+
+_ABSENT: Any = object()
+
+_CAPABILITIES = frozenset(
+    {
+        "files",
+        "adjacent-text-parts",
+        "interleaved-parts",
+        "rewind",
+        "rewind-during-run",
+        "assistant-edit",
+        "assistant-continuation",
+        "incomplete-continuation",
+    }
+)
+
+_ENTRY_TYPES = (
+    "message-send",
+    "message-edit",
+    "message-reload",
+    "input-resume",
+    "error-continue",
+    "stop-continue",
+)
+
+GetMessageMeta = Callable[[str], Awaitable[dict[str, Any] | None]]
+
+
+def _reject(reason: str, message: str) -> StatewireReject:
+    return StatewireReject(message, payload={"reason": reason})
+
+
+class RunManager:
+    def __init__(
+        self,
+        *,
+        state: Any,
+        start: Callable[["RunManager.StartContext"], Awaitable[Any]],
+        get_message_meta: GetMessageMeta,
+        create_task: Callable[[Any], "asyncio.Task[Any]"],
+        capabilities: Iterable[str] = (),
+        max_queued: int = 50,
+    ) -> None:
+        caps = frozenset(capabilities)
+        unknown = caps - _CAPABILITIES
+        if unknown:
+            raise ValueError(f"unknown capabilities: {sorted(unknown)}")
+        if "rewind-during-run" in caps and "rewind" not in caps:
+            raise ValueError("rewind-during-run requires the rewind capability")
+        if max_queued < 1:
+            raise ValueError("max_queued must be >= 1")
+        self._state = state
+        self._start = start
+        self._get_message_meta = get_message_meta
+        self._capabilities = caps
+        self._create_task = create_task
+        self._max_queued = max_queued
+        self._task: "asyncio.Task[Any] | None" = None
+        self._ctx: "RunManager.StartContext | None" = None
+        self._dispatched_ids: tuple[str, ...] = ()
+        self._dispatch_record: dict[str, Any] | None = None
+        self._callers: dict[str, StatewireClientHandle] = {}
+        self._init_state()
+
+    def _init_state(self) -> None:
+        # Runs state is write-only and not durable: overwrite whatever is there.
+        self._state["status"] = "ready"
+        self._state["error"] = None
+        self._state["queue"] = []
+        self._state["steerQueue"] = []
+        self._state.pop("dispatch", None)
+
+    def input_resume(self) -> None:
+        if self._status() != "input-required":
+            raise RuntimeError(
+                f"input_resume is only valid in input-required, not {self._status()!r}"
+            )
+        self._dispatch("input-resume", [])
+
+    # ─── State access ───────────────────────────────────────
+
+    def _status(self) -> str:
+        return self._state["status"]
+
+    def _lane_items(self, lane: str) -> list[dict[str, Any]]:
+        return list(plain(self._state[lane]))
+
+    def _lane_of(self, message_id: str) -> str | None:
+        for lane in ("steerQueue", "queue"):
+            if any(item["id"] == message_id for item in self._lane_items(lane)):
+                return lane
+        return None
+
+    def _continue_type(self) -> str:
+        return "error-continue" if self._status() == "error" else "stop-continue"
+
+    # ─── Dispatch and settle ────────────────────────────────
+
+    def _dispatch(
+        self,
+        type: str,
+        messages: list[dict[str, Any]],
+        *,
+        rollback_to: Any = _ABSENT,
+    ) -> None:
+        if type not in _ENTRY_TYPES:
+            raise ValueError(f"invalid entry type: {type!r}")
+        if self._task is not None:
+            raise RuntimeError("a run is already in flight")
+        caller = self._callers.get(messages[0]["id"]) if messages else None
+        messages = [
+            {k: v for k, v in message.items() if k != "caller"} for message in messages
+        ]
+        for message in messages:
+            self._callers.pop(message["id"], None)
+        record: dict[str, Any] = {"type": type, "messages": list(messages)}
+        if rollback_to is not _ABSENT:
+            record["rollbackTo"] = rollback_to
+        self._dispatch_record = record
+        self._state["error"] = None
+        if messages:
+            self._dispatched_ids = tuple(m["id"] for m in messages)
+        self._state["status"] = "running"
+        ctx = RunManager.StartContext(
+            type=type,
+            messages=tuple(messages),
+            caller=caller,
+            stop_requested=asyncio.Event(),
+            _manager=self,
+            _rollback_to=rollback_to,
+        )
+        self._ctx = ctx
+        self._task = self._create_task(self._run(ctx))
+
+    async def _run(self, ctx: "RunManager.StartContext") -> None:
+        try:
+            outcome = await self._start(ctx)
+            if not isinstance(
+                outcome,
+                (
+                    RunManager.Complete,
+                    RunManager.InputRequired,
+                    RunManager.Error,
+                    RunManager.Stop,
+                ),
+            ):
+                raise TypeError(
+                    "start must return a RunManager outcome, got "
+                    f"{type(outcome).__name__}"
+                )
+        except Exception as exc:
+            self._settle(ctx)
+            self._freeze(str(exc) or type(exc).__name__)
+            return
+        self._settle(ctx)
+        if isinstance(outcome, RunManager.Complete):
+            self._dispatched_ids = ()
+            if not self._drain():
+                self._state["status"] = "ready"
+            return
+        if isinstance(outcome, RunManager.InputRequired):
+            self._state["status"] = "input-required"
+            return
+        status = "error" if isinstance(outcome, RunManager.Error) else "stopped"
+        if outcome.dispatch_queue and self._drain():
+            return
+        self._state["status"] = status
+
+    def _settle(self, ctx: "RunManager.StartContext") -> None:
+        if self._ctx is ctx:
+            self._ctx = None
+            self._task = None
+        self._dispatch_record = None
+
+    def _drain(self) -> bool:
+        steer = self._lane_items("steerQueue")
+        if steer:
+            self._state["steerQueue"] = []
+            self._dispatch("message-send", steer)
+            return True
+        queue = self._lane_items("queue")
+        if queue:
+            self._state["queue"].pop(0)
+            self._dispatch("message-send", [queue[0]])
+            return True
+        return False
+
+    def _freeze(self, message: str) -> None:
+        self._state["status"] = "error"
+        self._state["error"] = {"message": message}
+
+    # ─── Message and placement validation ───────────────────
+
+    def _validated_message(self, message: Any) -> dict[str, Any]:
+        if not isinstance(message, dict):
+            raise _reject("invalid-message", "message must be an object")
+        if not isinstance(message.get("id"), str) or message["id"] == "":
+            raise _reject("invalid-message", "message.id must be a non-empty string")
+        if message.get("role") != "user":
+            raise _reject("invalid-message", 'message.role must be "user"')
+        parts = message.get("parts")
+        if not isinstance(parts, list) or len(parts) == 0:
+            raise _reject("invalid-message", "message.parts must be a non-empty array")
+        previous: str | None = None
+        seen_text = False
+        for part in parts:
+            kind = part.get("type") if isinstance(part, dict) else None
+            if kind == "text":
+                if not isinstance(part.get("text"), str):
+                    raise _reject("invalid-message", "text parts must carry a string text")
+                if previous == "text" and "adjacent-text-parts" not in self._capabilities:
+                    raise _reject(
+                        "invalid-message",
+                        "adjacent text parts require the adjacent-text-parts capability",
+                    )
+                seen_text = True
+            elif kind == "file":
+                if "files" not in self._capabilities:
+                    raise _reject("capability-missing", "the files capability is not enabled")
+                if not isinstance(part.get("mediaType"), str) or not isinstance(
+                    part.get("url"), str
+                ):
+                    raise _reject(
+                        "invalid-message", "file parts must carry mediaType and url"
+                    )
+                if seen_text and "interleaved-parts" not in self._capabilities:
+                    raise _reject(
+                        "invalid-message",
+                        "file parts after text require the interleaved-parts capability",
+                    )
+            else:
+                raise _reject("invalid-message", f"unknown part type: {kind!r}")
+            previous = kind
+        metadata = message.get("metadata", _ABSENT)
+        if metadata is not _ABSENT and not isinstance(metadata, dict):
+            raise _reject("invalid-message", "message.metadata must be an object")
+        return message
+
+    def _anchor_index(self, items: list[dict[str, Any]], anchor: str) -> int:
+        for index, item in enumerate(items):
+            if item["id"] == anchor:
+                return index
+        raise _reject("unknown-anchor", f"anchor {anchor} is not in the lane")
+
+    def _resolve_index(
+        self, items: list[dict[str, Any]], placement: dict[str, Any], fallback: int
+    ) -> int:
+        insert_after = placement.get("insertAfter", _ABSENT)
+        insert_before = placement.get("insertBefore", _ABSENT)
+        for name, value in (("insertAfter", insert_after), ("insertBefore", insert_before)):
+            if value is not _ABSENT and value is not None and not isinstance(value, str):
+                raise _reject("invalid-message", f"{name} must be an id or null")
+        if insert_before is _ABSENT:
+            if insert_after is _ABSENT:
+                return fallback
+            return 0 if insert_after is None else self._anchor_index(items, insert_after) + 1
+        if insert_after is _ABSENT:
+            return (
+                len(items)
+                if insert_before is None
+                else self._anchor_index(items, insert_before)
+            )
+        slot = 0 if insert_after is None else self._anchor_index(items, insert_after) + 1
+        if insert_before is not None:
+            self._anchor_index(items, insert_before)
+        at_slot = items[slot]["id"] if slot < len(items) else None
+        if at_slot != insert_before:
+            raise _reject("not-adjacent", "insertAfter and insertBefore are not adjacent")
+        return slot
+
+    # ─── Queue mutations ────────────────────────────────────
+
+    def _stamped(self, message: dict[str, Any]) -> dict[str, Any]:
+        entry = {k: v for k, v in message.items() if k != "caller"}
+        caller = self._callers.get(message["id"])
+        if caller is not None:
+            entry["caller"] = {"clientId": caller.client_id}
+        return entry
+
+    def _check_capacity(self, lane: str) -> None:
+        if len(self._lane_items(lane)) >= self._max_queued:
+            raise _reject(
+                "queue-full", f"queue is full ({self._max_queued} messages)"
+            )
+
+    def _place(
+        self,
+        target: str,
+        current: str,
+        message: dict[str, Any],
+        placement: dict[str, Any],
+    ) -> None:
+        lane_change = current != target
+        if lane_change:
+            self._check_capacity(target)
+        current_items = self._lane_items(current)
+        current_index = next(
+            i for i, item in enumerate(current_items) if item["id"] == message["id"]
+        )
+        without = [item for item in current_items if item["id"] != message["id"]]
+        base = self._lane_items(target) if lane_change else without
+        index = self._resolve_index(
+            base, placement, len(base) if lane_change else current_index
+        )
+        items = list(base)
+        items.insert(index, self._stamped(message))
+        if lane_change:
+            self._state[current] = without
+        self._state[target] = items
+        if target == "steerQueue" and self._status() in ("error", "stopped"):
+            self._dispatch(self._continue_type(), [])
+
+    def _add_new(
+        self, lane: str, message: dict[str, Any], placement: dict[str, Any]
+    ) -> None:
+        status = self._status()
+        if status == "ready":
+            self._dispatch("message-send", [message])
+            return
+        if status in ("error", "stopped"):
+            if lane == "steerQueue":
+                self._check_capacity(lane)
+                items = self._lane_items(lane)
+                items.insert(
+                    self._resolve_index(items, placement, len(items)),
+                    self._stamped(message),
+                )
+                self._state[lane] = items
+                self._dispatch(self._continue_type(), [])
+                return
+            if not self._lane_items("steerQueue") and not self._lane_items("queue"):
+                self._dispatch("message-send", [message])
+                return
+        self._check_capacity(lane)
+        items = self._lane_items(lane)
+        items.insert(
+            self._resolve_index(items, placement, len(items)), self._stamped(message)
+        )
+        self._state[lane] = items
+
+    async def _move(self, lane: str, message_id: Any, placement: dict[str, Any]) -> None:
+        if not isinstance(message_id, str):
+            raise _reject("invalid-message", "messageId must be a string")
+        current = self._lane_of(message_id)
+        if current is None:
+            if message_id in self._dispatched_ids:
+                if lane == "steerQueue":
+                    return
+                raise _reject(
+                    "already-dispatched", f"message {message_id} already dispatched"
+                )
+            raise _reject("unknown-id", f"message {message_id} is not queued")
+        item = next(i for i in self._lane_items(current) if i["id"] == message_id)
+        self._place(lane, current, item, placement)
+
+    async def _send(
+        self, lane: str, params: Any, caller: StatewireClientHandle | None
+    ) -> Any:
+        if not isinstance(params, dict):
+            raise _reject("invalid-message", "params must be an object")
+        has_message = "message" in params
+        has_message_id = "messageId" in params
+        if has_message == has_message_id:
+            raise _reject(
+                "invalid-message", "exactly one of message and messageId is required"
+            )
+        if not has_message:
+            return await self._move(lane, params["messageId"], params)
+        message = self._validated_message(params["message"])
+        message_id = message["id"]
+        previous = self._callers.get(message_id)
+        if caller is None:
+            self._callers.pop(message_id, None)
+        else:
+            self._callers[message_id] = caller
+        try:
+            current = self._lane_of(message_id)
+            if current is not None:
+                self._place(lane, current, message, params)
+                return None
+            if message_id in self._dispatched_ids:
+                return await self._edit_dispatched(message)
+            if await self._get_message_meta(message_id) is not None:
+                raise _reject("duplicate-id", f"message id {message_id} is already used")
+            self._add_new(lane, message, params)
+            return None
+        except StatewireReject:
+            if previous is None:
+                self._callers.pop(message_id, None)
+            else:
+                self._callers[message_id] = previous
+            raise
+
+    async def _edit_dispatched(self, message: dict[str, Any]) -> Any:
+        if self._task is not None:
+            if "rewind-during-run" not in self._capabilities:
+                raise _reject(
+                    "capability-missing",
+                    "editing during a run requires the rewind-during-run capability",
+                )
+        elif "rewind" not in self._capabilities:
+            raise _reject("capability-missing", "the rewind capability is not enabled")
+        meta = await self._get_message_meta(message["id"])
+        if meta is None:
+            raise _reject("unknown-id", f"message {message['id']} is unknown")
+        if self._task is not None and not meta["isLeaf"]:
+            raise _reject("not-leaf", "only the leaf may be edited during a run")
+        return self._rewind_dispatch("message-edit", [message], meta["parentId"])
+
+    def _rewind_dispatch(
+        self, type: str, messages: list[dict[str, Any]], rollback_to: Any
+    ) -> Any:
+        if self._task is None:
+            self._dispatch(type, messages, rollback_to=rollback_to)
+            return None
+
+        async def flow(ack: Callable[[], None]) -> None:
+            ack()
+            while self._task is not None:
+                assert self._ctx is not None
+                self._ctx.stop_requested.set()
+                await self._task
+            self._dispatch(type, messages, rollback_to=rollback_to)
+
+        return CommandExecution(flow)
+
+    # ─── Command handlers ───────────────────────────────────
+
+    async def enqueue(
+        self, params: Any, *, caller: StatewireClientHandle | None = None
+    ) -> Any:
+        return await self._send("queue", params, caller)
+
+    async def steer(
+        self, params: Any, *, caller: StatewireClientHandle | None = None
+    ) -> Any:
+        return await self._send("steerQueue", params, caller)
+
+    async def dequeue(self, params: Any) -> None:
+        message_id = params.get("messageId") if isinstance(params, dict) else None
+        if not isinstance(message_id, str):
+            raise _reject("invalid-message", "messageId must be a string")
+        lane = self._lane_of(message_id)
+        if lane is None:
+            raise _reject("unknown-id", f"message {message_id} is not queued")
+        self._callers.pop(message_id, None)
+        self._state[lane] = [
+            item for item in self._lane_items(lane) if item["id"] != message_id
+        ]
+
+    def _check_rewind_gate(self, command: str) -> None:
+        status = self._status()
+        if status == "input-required":
+            raise _reject("wrong-state", f"{command} is rejected in input-required")
+        if status == "running":
+            if "rewind-during-run" not in self._capabilities:
+                raise _reject(
+                    "capability-missing",
+                    f"{command} during a run requires the rewind-during-run capability",
+                )
+        elif "rewind" not in self._capabilities:
+            raise _reject("capability-missing", "the rewind capability is not enabled")
+
+    def _check_leaf(self, meta: dict[str, Any], command: str) -> None:
+        if meta["isLeaf"]:
+            return
+        if self._status() == "running":
+            raise _reject("not-leaf", f"only the leaf accepts {command} during a run")
+        if self._lane_items("steerQueue") or self._lane_items("queue"):
+            raise _reject(
+                "not-leaf",
+                f"only the leaf accepts {command} while the queue is non-empty",
+            )
+
+    async def edit(self, params: Any) -> Any:
+        self._check_rewind_gate("run/edit")
+        source_id = params.get("sourceId") if isinstance(params, dict) else None
+        if not isinstance(source_id, str):
+            raise _reject("invalid-message", "sourceId must be a string")
+        meta = await self._get_message_meta(source_id)
+        if meta is None:
+            raise _reject("unknown-id", f"message {source_id} is unknown")
+        self._check_leaf(meta, "run/edit")
+        if meta["role"] != "user" and "assistant-edit" not in self._capabilities:
+            raise _reject(
+                "capability-missing", "the assistant-edit capability is not enabled"
+            )
+        message = self._validated_message(
+            params.get("message") if isinstance(params, dict) else None
+        )
+        if message["id"] != source_id and (
+            self._lane_of(message["id"]) is not None
+            or await self._get_message_meta(message["id"]) is not None
+        ):
+            raise _reject("duplicate-id", f"message id {message['id']} is already used")
+        return self._rewind_dispatch("message-edit", [message], meta["parentId"])
+
+    async def reload(self, params: Any) -> Any:
+        self._check_rewind_gate("run/reload")
+        source_id = params.get("sourceId") if isinstance(params, dict) else None
+        if not isinstance(source_id, str):
+            raise _reject("invalid-message", "sourceId must be a string")
+        meta = await self._get_message_meta(source_id)
+        if meta is None:
+            raise _reject("unknown-id", f"message {source_id} is unknown")
+        if meta["role"] != "assistant":
+            raise _reject("invalid-message", "sourceId must name an assistant message")
+        self._check_leaf(meta, "run/reload")
+        if meta["parentId"] is not None:
+            parent = await self._get_message_meta(meta["parentId"])
+            if (
+                parent is not None
+                and parent["role"] == "assistant"
+                and "assistant-continuation" not in self._capabilities
+            ):
+                raise _reject(
+                    "capability-missing",
+                    "the assistant-continuation capability is not enabled",
+                )
+        return self._rewind_dispatch("message-reload", [], meta["parentId"])
+
+    async def stop(self) -> Any:
+        status = self._status()
+        if status == "running":
+            task = self._task
+            ctx = self._ctx
+            assert task is not None and ctx is not None
+            ctx.stop_requested.set()
+
+            async def settle(ack: Callable[[], None]) -> None:
+                ack()
+                await task
+
+            return CommandExecution(settle)
+        if status == "input-required":
+            self._state["status"] = "stopped"
+            return None
+        raise _reject("wrong-state", f"run/stop is rejected in {status}")
+
+    async def continue_run(self) -> None:
+        status = self._status()
+        if status not in ("error", "stopped"):
+            raise _reject("wrong-state", f"run/continue is rejected in {status}")
+        if not self._lane_items("steerQueue") and (
+            "incomplete-continuation" not in self._capabilities
+        ):
+            raise _reject(
+                "capability-missing",
+                "bare continue requires the incomplete-continuation capability",
+            )
+        self._dispatch(self._continue_type(), [])
+
+    # ─── Outcomes and context ───────────────────────────────
+
+    @dataclass(frozen=True)
+    class Complete:
+        pass
+
+    @dataclass(frozen=True)
+    class InputRequired:
+        pass
+
+    @dataclass(frozen=True, kw_only=True)
+    class Error:
+        dispatch_queue: bool
+
+    @dataclass(frozen=True, kw_only=True)
+    class Stop:
+        dispatch_queue: bool
+
+    @dataclass(frozen=True, eq=False)
+    class StartContext:
+        type: str
+        messages: tuple[dict[str, Any], ...]
+        caller: StatewireClientHandle | None
+        stop_requested: asyncio.Event
+        _manager: "RunManager"
+        _rollback_to: Any
+
+        @property
+        def has_rollback(self) -> bool:
+            return self._rollback_to is not _ABSENT
+
+        @property
+        def rollback_to(self) -> str | None:
+            if self._rollback_to is _ABSENT:
+                raise AttributeError(
+                    "rollback_to is only present on rewind entries; check has_rollback"
+                )
+            return self._rollback_to
+
+        def _ensure_active(self) -> None:
+            if self._manager._ctx is not self:
+                raise RuntimeError("this run has already settled")
+
+        def has_steered(self) -> bool:
+            self._ensure_active()
+            return len(self._manager._lane_items("steerQueue")) > 0
+
+        def take_steered(self) -> tuple[dict[str, Any], ...]:
+            self._ensure_active()
+            items = self._manager._lane_items("steerQueue")
+            self._manager._state["steerQueue"] = []
+            for item in items:
+                self._manager._callers.pop(item["id"], None)
+            return tuple(
+                {k: v for k, v in item.items() if k != "caller"} for item in items
+            )
+
+        def set_recovery_state(self, value: Any) -> None:
+            self._ensure_active()
+            record = self._manager._dispatch_record
+            assert record is not None
+            record["recoveryState"] = value

harness_sdk_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: harness-sdk-python
+Version: 0.1.0
+Summary: RunManager: the harness-sdk runs subsystem for Python Statewire hosts
+Project-URL: Repository, https://github.com/assistant-ui/harness-sdk
+License-Expression: MIT
+Requires-Python: <4.0,>=3.11
+Requires-Dist: statewire<0.3,>=0.2.0
+Description-Content-Type: text/markdown
+
+# harness-sdk-python
+
+RunManager: the harness-sdk runs subsystem for Python Statewire hosts — the
+`run/*` command protocol (queues, steering, edit/reload, stop/resume, crash
+replay) driving a single async `start(ctx)` executor entrypoint.
+
+```python
+class MyHost(Statewire):
+    async def lifespan(self):
+        self.state = initial_state()
+        self.runs = RunManager(
+            state=self.state["runs"],
+            start=self._start,
+            get_message_meta=self._get_message_meta,
+            create_task=self.create_task,
+            capabilities=("rewind",),
+        )
+        yield
+
+    @command("run/enqueue")
+    async def run_enqueue(self, params, *, caller):
+        return await self.runs.enqueue(params, caller=caller)
+
+    @command("run/steer")
+    async def run_steer(self, params, *, caller):
+        return await self.runs.steer(params, caller=caller)
+
+    @command("run/dequeue")
+    async def run_dequeue(self, params):
+        return await self.runs.dequeue(params)
+
+    @command("run/edit")
+    async def run_edit(self, params):
+        return await self.runs.edit(params)
+
+    @command("run/reload")
+    async def run_reload(self, params):
+        return await self.runs.reload(params)
+
+    @command("run/stop")
+    async def run_stop(self):
+        return await self.runs.stop()
+
+    @command("run/continue")
+    async def run_continue(self):
+        return await self.runs.continue_run()
+```

harness_sdk_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+harness_sdk/__init__.py,sha256=E4jrA6uGoPEPuCW0NGJKTAK6s8Ue5S8-b29ydtjYNSA,62
+harness_sdk/run_manager.py,sha256=2Gdt_gW95mUajousNW0VZlmW-cXGTVzqZrhdegFsOyg,25325
+harness_sdk_python-0.1.0.dist-info/METADATA,sha256=OW4L3fTDs0_AptpDarTDoBl1S9_xPKJl27lHJEcggTI,1770
+harness_sdk_python-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+harness_sdk_python-0.1.0.dist-info/RECORD,,

harness_sdk_python-0.1.0.dist-info/WHEEL

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