netizen-cli 0.10.0__py3-none-any.whl

netizen_cli/turn_patch_children.py

@@ -0,0 +1,254 @@
+"""Read successful patches from children created by one exact native Turn.
+
+These bounded, best-effort reads use the public SDK and do not resume Threads.
+They are a completion-time snapshot, not an atomic snapshot of the task tree.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections import deque
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+from openai_codex import AsyncThread
+from openai_codex.generated.v2_all import (
+    CollabAgentToolCallThreadItem,
+    FileChangeThreadItem,
+    SubAgentActivityThreadItem,
+    SubAgentSessionSource,
+    Thread,
+    ThreadItem,
+    ThreadReadResponse,
+    ThreadSpawnSubAgentSource,
+)
+
+
+_MAX_CHILDREN = 32
+_READ_TIMEOUT_SECONDS = 3.0
+
+
+@dataclass(frozen=True, slots=True)
+class TurnPatchBatch:
+    thread_id: str
+    turn_id: str
+    cwd: Path
+    items: tuple[object, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class TaskPatchChildren:
+    batches: tuple[TurnPatchBatch, ...] = ()
+    complete: bool = True
+
+
+def _item(value: object) -> object:
+    return value.root if type(value) is ThreadItem else value
+
+
+def _value(value: object) -> object:
+    return getattr(value, "value", value)
+
+
+def _child_edges(
+    items: Sequence[object], parent_id: str
+) -> tuple[set[str], set[str], bool]:
+    spawned: set[str] = set()
+    referenced: set[str] = set()
+    complete = True
+    for wrapped in items:
+        item = _item(wrapped)
+        if type(item) is CollabAgentToolCallThreadItem:
+            tool = _value(item.tool)
+            # These controls neither create work nor identify a child Turn.
+            # listAgents can legitimately have no receivers at all.
+            if tool in {"closeAgent", "interruptAgent", "listAgents"}:
+                continue
+            if item.sender_thread_id != parent_id:
+                complete = False
+                continue
+            if _value(item.status) != "completed":
+                if _value(item.status) in {"inProgress", "interrupted"}:
+                    complete = False
+                continue
+            receivers = set(item.receiver_thread_ids)
+            # V2 wait_agent observes mailbox activity without targeting any
+            # Thread. V1 waits with receivers still carry those references.
+            if tool == "wait" and not receivers and not item.agents_states:
+                continue
+            if not receivers or any(not receiver for receiver in receivers):
+                complete = False
+                continue
+            if tool == "spawnAgent":
+                spawned.update(receivers)
+            elif tool in {
+                "sendInput", "resumeAgent", "wait", "sendMessage", "followupTask"
+            }:
+                referenced.update(receivers)
+        elif type(item) is SubAgentActivityThreadItem:
+            if not item.agent_thread_id:
+                complete = False
+            elif _value(item.kind) == "started":
+                spawned.add(item.agent_thread_id)
+            elif _value(item.kind) in {"interacted", "completed"}:
+                # Completion may belong to a follow-up on an existing child.
+                # Its opaque item ID is not a public child Turn identity.
+                referenced.add(item.agent_thread_id)
+    return spawned, referenced, complete
+
+
+def _has_parent(thread: Thread, parent_id: str) -> bool:
+    parents = []
+    if thread.parent_thread_id is not None:
+        parents.append(thread.parent_thread_id)
+    source = thread.source.root
+    if type(source) is SubAgentSessionSource:
+        child_source = source.sub_agent.root
+        if type(child_source) is ThreadSpawnSubAgentSource:
+            parents.append(child_source.thread_spawn.parent_thread_id.root)
+    return (
+        bool(parents)
+        and all(parent == parent_id for parent in parents)
+        and thread.forked_from_id in {None, parent_id}
+    )
+
+
+async def _read_thread(codex: object, thread_id: str) -> Thread:
+    response = await AsyncThread(codex, thread_id).read(include_turns=True)
+    if type(response) is not ThreadReadResponse or response.thread.id != thread_id:
+        raise ValueError("native child patch read identity mismatch")
+    thread = response.thread
+    ids = [turn.id for turn in thread.turns]
+    if any(not turn_id for turn_id in ids) or len(set(ids)) != len(ids):
+        raise ValueError("native child patch read has ambiguous Turn identities")
+    return thread
+
+
+async def collect_turn_patch_children(
+    codex: object,
+    *,
+    thread_id: str,
+    turn_id: str,
+    items: Sequence[object],
+) -> TaskPatchChildren:
+    """Collect new descendants, retaining known patches when evidence is partial.
+
+    Old children cannot be assigned to this Turn using the SDK's Thread-only
+    collab references. They make the result partial without importing history.
+    Ancestor Turn IDs exclude the history copied by native subagent forks.
+    """
+    spawned, references, complete = _child_edges(items, thread_id)
+    if not spawned:
+        return TaskPatchChildren(complete=complete and not references)
+
+    batches: list[TurnPatchBatch] = []
+    parents = {thread_id: ""}
+    pending: deque[tuple[str, str, frozenset[str]]] = deque()
+
+    def enqueue(
+        child_ids: set[str], parent_id: str, ancestor_turns: frozenset[str]
+    ) -> None:
+        nonlocal complete
+        for child_id in sorted(child_ids):
+            if child_id in parents:
+                if parents[child_id] != parent_id:
+                    complete = False
+                continue
+            if len(parents) - 1 >= _MAX_CHILDREN:
+                complete = False
+                continue
+            parents[child_id] = parent_id
+            pending.append((child_id, parent_id, ancestor_turns))
+
+    try:
+        async with asyncio.timeout(_READ_TIMEOUT_SECONDS):
+            try:
+                root = await _read_thread(codex, thread_id)
+            except Exception:
+                return TaskPatchChildren(complete=False)
+            root_ids = [turn.id for turn in root.turns]
+            # A newer root Turn may already have sent another task to the same
+            # child. Its child Turn identity is not exposed by this SDK.
+            # Root items are already frozen by the caller. Here only Turn IDs
+            # are used; items_view describes item contents, not those identities.
+            if not root_ids or root_ids[-1] != turn_id:
+                return TaskPatchChildren(complete=False)
+            enqueue(spawned, thread_id, frozenset(root_ids))
+            while pending:
+                child_id, parent_id, ancestor_turns = pending.popleft()
+                try:
+                    child = await _read_thread(codex, child_id)
+                    if not _has_parent(child, parent_id):
+                        raise ValueError("native child patch read parent mismatch")
+                    cwd = Path(child.cwd.root)
+                    if not cwd.is_absolute():
+                        raise ValueError("native child patch read cwd is not absolute")
+                except Exception:
+                    complete = False
+                    continue
+                own_turns = [
+                    turn for turn in child.turns if turn.id not in ancestor_turns
+                ]
+                if not own_turns:
+                    complete = False
+                child_ancestors = ancestor_turns | frozenset(
+                    turn.id for turn in child.turns
+                )
+                for turn in own_turns:
+                    if (
+                        _value(turn.status) == "inProgress"
+                        or _value(turn.items_view) != "full"
+                    ):
+                        complete = False
+                    patches = {}
+                    conflicting = set()
+                    for wrapped in turn.items:
+                        item = _item(wrapped)
+                        if type(item) is not FileChangeThreadItem:
+                            continue
+                        if _value(item.status) == "inProgress":
+                            complete = False
+                        elif _value(item.status) == "completed":
+                            if item.id in conflicting:
+                                continue
+                            if item.id in patches and patches[item.id] != item:
+                                complete = False
+                                conflicting.add(item.id)
+                                del patches[item.id]
+                                continue
+                            patches[item.id] = item
+                    if patches:
+                        batches.append(
+                            TurnPatchBatch(
+                                child_id, turn.id, cwd, tuple(patches.values())
+                            )
+                        )
+                    new_children, related, edges_complete = _child_edges(
+                        turn.items, child_id
+                    )
+                    complete = complete and edges_complete
+                    references.update(related)
+                    enqueue(new_children, child_id, child_ancestors)
+            # Admission may open while this best-effort display read is running.
+            # A new root Turn can follow up with these same children, so validate
+            # the boundary again before publishing any child evidence.
+            if len(parents) > 1:
+                try:
+                    final_root = await _read_thread(codex, thread_id)
+                except Exception:
+                    return TaskPatchChildren(complete=False)
+                if not final_root.turns or final_root.turns[-1].id != turn_id:
+                    return TaskPatchChildren(complete=False)
+    except TimeoutError:
+        # Without the closing root read, earlier successful child reads may
+        # already include work from a newly admitted root Turn.
+        return TaskPatchChildren(complete=False)
+    # Resolve references after the traversal: siblings may communicate before
+    # their spawn item is encountered in another member of this task tree.
+    # A reply to this root is also known: both root reads proved the exact Turn,
+    # whose patches the caller already froze. Never import root history here.
+    return TaskPatchChildren(
+        batches=tuple(batches),
+        complete=complete and references.issubset(parents),
+    )

netizen_cli/turn_plan_observer.py

@@ -0,0 +1,315 @@
+"""Pinned, non-consuming observation of one active Turn's retained activity.
+
+This is the complete private-SDK exception approved by ADR 0020 and extended
+by ADR 0052.  It never registers, consumes, or mutates notifications and
+exposes no generic queue or RPC access.
+"""
+
+from __future__ import annotations
+
+import threading
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol
+
+import openai_codex
+from openai_codex import AsyncCodex
+from openai_codex._message_router import MessageRouter, _TurnState
+from openai_codex.async_client import AsyncCodexClient
+from openai_codex.client import CodexClient
+from openai_codex.generated.v2_all import (
+    ItemCompletedNotification,
+    ItemStartedNotification,
+    TurnCompletedNotification,
+    TurnPlanStep,
+    TurnPlanStepStatus,
+    TurnPlanUpdatedNotification,
+    TurnStartedNotification,
+)
+from openai_codex.models import Notification
+
+from .terminal_cleanup import _source_tree_fingerprint
+from .user_questions import QuestionRequest
+from .turn_activity import (
+    TurnActivityEvent,
+    TurnActivityProjectionUnavailable,
+    TurnPlanStepSnapshot,
+    TurnPlanStepState,
+    project_turn_activity_notification,
+)
+
+
+SUPPORTED_SDK_VERSION = "0.156.1"
+_PACKAGE_SOURCE_FINGERPRINT = (
+    "7d0a2267e45d39934c64d2c01bddde8b36eacb2d771dd6903a056c6abef8e94f"
+)
+_LOCK_TYPE = type(threading.RLock())
+
+
+class TurnActivityObservationUnavailable(RuntimeError):
+    """The pinned read-only observation contract cannot be satisfied."""
+
+
+@dataclass(frozen=True, slots=True)
+class TurnActivityObservation:
+    next_cursor: int
+    plan_updated: bool
+    plan_cursor: int | None = None
+    steps: tuple[TurnPlanStepSnapshot, ...] = ()
+    events: tuple[TurnActivityEvent, ...] = ()
+    turn_completed: bool = False
+    retained_count: int = 0
+    questions: tuple[QuestionRequest, ...] = ()
+
+    def __post_init__(self) -> None:
+        if self.next_cursor < 0:
+            raise ValueError("plan observation cursor must be non-negative")
+        if (
+            type(self.retained_count) is not int
+            or not 0 <= self.retained_count <= self.next_cursor
+        ):
+            raise ValueError("retained notification count must fall within the cursor")
+        if self.plan_updated != (self.plan_cursor is not None):
+            raise ValueError("plan cursor must identify exactly one plan update")
+        if self.plan_cursor is not None and not 0 < self.plan_cursor <= self.next_cursor:
+            raise ValueError("plan update cursor must fall within the observation")
+
+
+class TurnActivityObserver(Protocol):
+    def observe(
+        self,
+        *,
+        thread_id: str,
+        turn_id: str,
+        after_cursor: int,
+    ) -> TurnActivityObservation: ...
+
+
+class PinnedTurnActivityObserver:
+    """Peek at already-routed safe activity without consuming notifications."""
+
+    __slots__ = ("_router",)
+
+    def __init__(self, codex: AsyncCodex) -> None:
+        self._router = _validate_contract(codex)
+
+    def observe(
+        self,
+        *,
+        thread_id: str,
+        turn_id: str,
+        after_cursor: int,
+    ) -> TurnActivityObservation:
+        _validate_exact_id(thread_id, label="Thread")
+        _validate_exact_id(turn_id, label="Turn")
+        if isinstance(after_cursor, bool) or not isinstance(after_cursor, int):
+            raise ValueError("activity cursor must be an integer")
+        if after_cursor < 0:
+            raise ValueError("activity cursor must be non-negative")
+
+        items, next_cursor, retained_count = self._snapshot_events(
+            thread_id, turn_id, after_cursor
+        )
+        latest_steps: tuple[TurnPlanStepSnapshot, ...] = ()
+        latest_cursor: int | None = None
+        events: list[TurnActivityEvent] = []
+        questions: list[QuestionRequest] = []
+        turn_completed = False
+        for item_cursor, item in enumerate(items, start=after_cursor + 1):
+            if isinstance(item, BaseException):
+                raise TurnActivityObservationUnavailable(
+                    "native Turn event store contains a transport failure"
+                )
+            if type(item) is not Notification:
+                raise TurnActivityObservationUnavailable(
+                    "native Turn notification item shape changed"
+                )
+            try:
+                projection = project_turn_activity_notification(
+                    item,
+                    expected_thread_id=thread_id,
+                    expected_turn_id=turn_id,
+                )
+            except TurnActivityProjectionUnavailable as error:
+                raise TurnActivityObservationUnavailable(str(error)) from error
+            if projection.plan_updated:
+                latest_steps = projection.steps
+                latest_cursor = item_cursor
+            if projection.event is not None:
+                events.append(projection.event)
+            if projection.question is not None:
+                questions.append(projection.question)
+            turn_completed = turn_completed or projection.turn_completed
+
+        return TurnActivityObservation(
+            next_cursor=next_cursor,
+            plan_updated=latest_cursor is not None,
+            plan_cursor=latest_cursor,
+            steps=latest_steps,
+            events=tuple(events),
+            turn_completed=turn_completed,
+            retained_count=retained_count,
+            questions=tuple(questions),
+        )
+
+    def _snapshot_events(
+        self,
+        thread_id: str,
+        turn_id: str,
+        after_cursor: int,
+    ) -> tuple[tuple[object, ...], int, int]:
+        router = self._router
+        lock = getattr(router, "_lock", None)
+        states = getattr(router, "_turn_states", None)
+        if type(lock) is not _LOCK_TYPE or type(states) is not dict:
+            raise TurnActivityObservationUnavailable(
+                "native notification router shape changed"
+            )
+        with lock:
+            state = states.get(turn_id)
+            if type(state) is not _TurnState:
+                raise TurnActivityObservationUnavailable(
+                    "exact native Turn event store is unavailable"
+                )
+            if (
+                getattr(state, "id", None) != turn_id
+                or getattr(state, "thread_id", None) != thread_id
+            ):
+                raise TurnActivityObservationUnavailable(
+                    "native Turn event store identity changed"
+                )
+            raw_items = getattr(state, "events", None)
+            first_cursor = getattr(state, "first_event", None)
+            next_cursor = getattr(state, "next_event", None)
+            subscribers = getattr(state, "subscribers", None)
+            if (
+                type(raw_items) is not dict
+                or type(first_cursor) is not int
+                or type(next_cursor) is not int
+                or not 0 <= first_cursor <= next_cursor
+                or type(getattr(state, "completed", None)) is not bool
+                or type(subscribers) is not dict
+                or not subscribers
+                or any(
+                    type(cursor) is not int
+                    or not first_cursor <= cursor <= next_cursor
+                    for cursor in subscribers.values()
+                )
+            ):
+                raise TurnActivityObservationUnavailable(
+                    "native Turn event store shape changed"
+                )
+            retained_count = len(raw_items)
+            if retained_count != next_cursor - first_cursor or any(
+                type(cursor) is not int or not first_cursor <= cursor < next_cursor
+                for cursor in raw_items
+            ):
+                raise TurnActivityObservationUnavailable(
+                    "native Turn event store has a cursor gap"
+                )
+            if after_cursor < first_cursor:
+                raise TurnActivityObservationUnavailable(
+                    "native Turn events were pruned before the observation cursor"
+                )
+            if after_cursor > next_cursor:
+                raise TurnActivityObservationUnavailable(
+                    "native Turn event cursor moved backwards"
+                )
+            # Cursor positions are absolute event indices. Copy only references;
+            # the SDK subscriptions retain exclusive consumption/pruning rights.
+            items = tuple(raw_items[cursor] for cursor in range(after_cursor, next_cursor))
+        return items, next_cursor, retained_count
+
+
+def _validate_contract(codex: AsyncCodex) -> MessageRouter:
+    if openai_codex.__version__ != SUPPORTED_SDK_VERSION:
+        raise TurnActivityObservationUnavailable(
+            "Turn activity observation supports only openai-codex=="
+            f"{SUPPORTED_SDK_VERSION}; found {openai_codex.__version__}"
+        )
+    if type(codex) is not AsyncCodex:
+        raise TurnActivityObservationUnavailable("AsyncCodex implementation type changed")
+    if getattr(codex, "_initialized", False) is not True:
+        raise TurnActivityObservationUnavailable(
+            "AsyncCodex must be initialized before Turn activity observation is enabled"
+        )
+    client = getattr(codex, "_client", None)
+    if type(client) is not AsyncCodexClient:
+        raise TurnActivityObservationUnavailable("AsyncCodex private client shape changed")
+    sync_client = getattr(client, "_sync", None)
+    if type(sync_client) is not CodexClient:
+        raise TurnActivityObservationUnavailable(
+            "AsyncCodexClient private sync client shape changed"
+        )
+    router = getattr(sync_client, "_router", None)
+    if type(router) is not MessageRouter:
+        raise TurnActivityObservationUnavailable("Codex notification router shape changed")
+    if type(getattr(router, "_lock", None)) is not _LOCK_TYPE:
+        raise TurnActivityObservationUnavailable("Codex notification router lock changed")
+    if type(getattr(router, "_turn_states", None)) is not dict:
+        raise TurnActivityObservationUnavailable("Codex Turn route catalog shape changed")
+
+    _validate_generated_models()
+    package_file = getattr(openai_codex, "__file__", None)
+    if not isinstance(package_file, str) or not package_file.endswith(".py"):
+        raise TurnActivityObservationUnavailable("cannot locate SDK source package")
+    try:
+        actual = _source_tree_fingerprint(Path(package_file).resolve().parent)
+    except OSError as error:
+        raise TurnActivityObservationUnavailable(
+            "cannot read SDK source package"
+        ) from error
+    if actual != _PACKAGE_SOURCE_FINGERPRINT:
+        raise TurnActivityObservationUnavailable(
+            "SDK package source fingerprint changed"
+        )
+    return router
+
+
+def _validate_generated_models() -> None:
+    payload_fields = getattr(TurnPlanUpdatedNotification, "model_fields", {})
+    if set(payload_fields) != {"explanation", "plan", "thread_id", "turn_id"}:
+        raise TurnActivityObservationUnavailable("Turn plan payload fields changed")
+    if {
+        name: getattr(payload_fields.get(name), "alias", None)
+        for name in ("explanation", "thread_id", "turn_id", "plan")
+    } != {
+        "explanation": None,
+        "thread_id": "threadId",
+        "turn_id": "turnId",
+        "plan": None,
+    }:
+        raise TurnActivityObservationUnavailable("Turn plan payload fields changed")
+    if getattr(payload_fields["explanation"], "default", object()) is not None:
+        raise TurnActivityObservationUnavailable("Turn plan explanation default changed")
+    step_fields = getattr(TurnPlanStep, "model_fields", {})
+    if set(step_fields) != {"step", "status"}:
+        raise TurnActivityObservationUnavailable("Turn plan step fields changed")
+    if {member.value for member in TurnPlanStepStatus} != {
+        "pending",
+        "inProgress",
+        "completed",
+    }:
+        raise TurnActivityObservationUnavailable("Turn plan step statuses changed")
+
+    expected_notification_fields = {
+        ItemStartedNotification: {"item", "started_at_ms", "thread_id", "turn_id"},
+        ItemCompletedNotification: {
+            "completed_at_ms",
+            "item",
+            "thread_id",
+            "turn_id",
+        },
+        TurnStartedNotification: {"thread_id", "turn"},
+        TurnCompletedNotification: {"thread_id", "turn"},
+    }
+    for model, expected_fields in expected_notification_fields.items():
+        if set(getattr(model, "model_fields", {})) != expected_fields:
+            raise TurnActivityObservationUnavailable(
+                f"{model.__name__} fields changed"
+            )
+
+
+def _validate_exact_id(value: str, *, label: str) -> None:
+    if not isinstance(value, str) or not value or value.strip() != value:
+        raise ValueError(f"native {label} ID must be a non-empty trimmed string")

netizen_cli/user_questions.py

@@ -0,0 +1,106 @@
+"""Native question display data and Codex 0.156.1 answer formatting.
+
+These are presentation values, not pending requests or a question lifecycle.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+
+
+_TARGET_ID = re.compile(r"[A-Za-z0-9][A-Za-z0-9-]{0,127}")
+
+
+def _validate_target_id(value: str) -> None:
+    if not isinstance(value, str) or _TARGET_ID.fullmatch(value) is None:
+        raise ValueError("question target requires an exact Binding or Side identity")
+
+
+@dataclass(frozen=True, slots=True)
+class BindingQuestionTarget:
+    binding_id: str
+
+    def __post_init__(self) -> None:
+        _validate_target_id(self.binding_id)
+
+
+@dataclass(frozen=True, slots=True)
+class SideQuestionTarget:
+    side_id: str
+
+    def __post_init__(self) -> None:
+        _validate_target_id(self.side_id)
+
+
+QuestionTarget = BindingQuestionTarget | SideQuestionTarget
+
+
+def question_target_payload(target: QuestionTarget) -> dict[str, str]:
+    """Reference an existing input target without introducing another identity."""
+
+    if isinstance(target, BindingQuestionTarget):
+        return {"kind": "binding", "id": target.binding_id}
+    if isinstance(target, SideQuestionTarget):
+        return {"kind": "side", "id": target.side_id}
+    raise TypeError("question target must reference a Binding or Side")
+
+
+@dataclass(frozen=True, slots=True)
+class UserQuestion:
+    title: str
+    options: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True, slots=True)
+class QuestionRequest:
+    item_id: str
+    questions: tuple[UserQuestion, ...]
+
+
+def question_item_id(item_id: str, question_index: int) -> str:
+    """Match the official client's identity for one question in an item."""
+
+    return json.dumps(
+        ["request_user_input_async", item_id, question_index],
+        ensure_ascii=False,
+        separators=(",", ":"),
+    )
+
+
+def format_question_answer(
+    item_id: str, question_index: int, title: str, answer: str
+) -> str:
+    """Render the native 0.156.1 answered-question fragment.
+
+    The title's UTF-8 byte bound and overlong-identity fallback layout match
+    context-fragments/src/answered_question.rs. Model-authored dollar signs use
+    Unicode escapes so native raw-text scanning cannot turn them into Skills.
+    In the plain fallback these remain readable literal escape sequences.
+    """
+
+    question_id = question_item_id(item_id, question_index)
+    bounded_title = title.encode("utf-8")[:512].decode("utf-8", errors="ignore")
+    bounded_title = bounded_title.replace("\n", " ").replace("\r", " ")
+    if len(question_id.encode("utf-8")) > 512:
+        inert_title = bounded_title.replace("$", "\\u0024")
+        return f"> {inert_title}\n\n{answer}"
+
+    def model_text(value: str) -> str:
+        return json.dumps(value, ensure_ascii=False).replace("$", "\\u0024")
+
+    body = (
+        '[{"answer":'
+        + json.dumps(answer, ensure_ascii=False)
+        + ',"question":'
+        + model_text(bounded_title)
+        + ',"questionItemId":'
+        + model_text(question_id)
+        + "}]"
+    )
+    return (
+        "<send_user_message_question_reply>\n"
+        + body
+        + "\n</send_user_message_question_reply>"
+    )

netizen_cli-0.10.0.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: netizen-cli
+Version: 0.10.0
+Summary: Use native Codex threads through a Feishu Channel.
+Requires-Python: <3.15,>=3.11
+Requires-Dist: h11==0.16.0
+Requires-Dist: lark-channel-sdk==1.4.0
+Requires-Dist: lark-oapi==1.7.2
+Requires-Dist: markdown-it-py==4.0.0
+Requires-Dist: mdformat==1.0.0
+Requires-Dist: mdformat-gfm==1.0.0
+Requires-Dist: mcp==2.2.0
+Requires-Dist: openai-codex==0.156.1
+Requires-Dist: pydantic==2.13.4
+Requires-Dist: PyYAML==6.0.3
+Requires-Dist: qrcode==8.2
+Requires-Dist: truststore==0.10.4; sys_platform == "darwin"
+Requires-Dist: uvicorn==0.52.4