agentengine-sdk-python 0.8.4__py3-none-any.whl → 0.8.6__py3-none-any.whl

ksadk/studio/shared_web_response_events.py

@@ -0,0 +1,180 @@
+"""Project committed Studio run events onto the Responses stream."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ksadk.studio import shared_web_run_state as run_state
+
+_APPROVAL_DECISIONS = {
+    "approve": "approved",
+    "approved": "approved",
+    "approved_session": "approved",
+    "allow": "approved",
+    "accept": "approved",
+    "accepted": "approved",
+    "reject": "rejected",
+    "rejected": "rejected",
+    "deny": "rejected",
+    "denied": "rejected",
+    "decline": "rejected",
+    "cancel": "cancelled",
+    "canceled": "cancelled",
+    "cancelled": "cancelled",
+}
+
+
+async def project_response_events(
+    self,
+    *,
+    session_id: str,
+    agent_id: str,
+    invocation_id: str,
+    seen: set[tuple[str, int]],
+) -> list[tuple[str, dict[str, Any]]]:
+    projected: list[tuple[str, dict[str, Any]]] = []
+    current_run_id = self._run_ids_by_invocation.get(invocation_id)
+    if not current_run_id:
+        return projected
+    for run in self.studio.event_store.list_runs(session_id=session_id):
+        if run.agent_id != agent_id or run.id != current_run_id:
+            continue
+        control = run_state.control_ready_event(self.studio, run.id, invocation_id)
+        if control and (run.id, -1) not in seen:
+            projected.append(control)
+            seen.add((run.id, -1))
+        events = await self.studio.run_service.events(run.id)
+        starts = {
+            str(event.data.get("callId") or event.data.get("call_id") or ""): event.data
+            for event in events
+            if event.type in {"command.started", "tool.started", "tool.requested"}
+        }
+        for event in events:
+            key = (run.id, event.id)
+            if key in seen:
+                continue
+            seen.add(key)
+            if event.type == "message.completed":
+                native = event.data.get("runtimeEvent") or {}
+                metadata = native.get("source", {}).get("metadata", {})
+                if (metadata.get("engine_kind") == "native"
+                        and metadata.get("native_event_kind") == "effect.received"
+                        and metadata.get("provisional") is True
+                        and metadata.get("provisional_retired") is not True):
+                    # Native retains a completed draft only when the sealed
+                    # model turn contains tool calls. Publish that commentary
+                    # once; rejected/truncated/final previews remain in trace.
+                    text = str(event.data.get("text") or "")
+                    if text:
+                        name = "response.output_text.delta"
+                        projected.append((name, self._response_delta_payload(
+                            name, invocation_id=invocation_id, delta=text,
+                        )))
+                continue
+            if event.type in {"message.delta", "thinking.delta"}:
+                delta = str(event.data.get("text") or event.data.get("delta") or "")
+                if not delta:
+                    continue
+                native = event.data.get("runtimeEvent") or {}
+                metadata = native.get("source", {}).get("metadata", {})
+                if (metadata.get("engine_kind") == "native"
+                        and metadata.get("provisional") is True):
+                    # The published Responses client appends text immediately;
+                    # it cannot retract a draft when the canonical item is
+                    # retired after an output limit or rejected candidate.
+                    # Preserve draft observations in the native ledger and
+                    # trace; sealed tool commentary and final delivery have
+                    # distinct completion events below/above this branch.
+                    # Never infer reasoning from prose or relabel it as such.
+                    continue
+                is_activity = run.runtime_type == "harness" and (
+                    metadata.get("native_event_type", metadata.get("native_event_kind"))
+                    == "run.progress"
+                )
+                event_name = (
+                    "response.output_text.delta"
+                    if event.type == "message.delta" and not is_activity
+                    else "response.reasoning_summary_text.delta"
+                )
+                projected.append(
+                    (
+                        event_name,
+                        self._response_delta_payload(
+                            event_name,
+                            invocation_id=invocation_id,
+                            delta=f"\n{delta}\n" if is_activity else delta,
+                        ),
+                    )
+                )
+                continue
+            if event.type.startswith("a2ui."):
+                projected.append(
+                    (
+                        event.type,
+                        {
+                            "type": event.type,
+                            "runId": run.id,
+                            **event.data,
+                        },
+                    )
+                )
+                continue
+            if event.type == "run.paused":
+                projected.append(
+                    (
+                        "response.paused",
+                        {
+                            "type": "response.paused",
+                            "response_id": invocation_id,
+                            "runId": run.id,
+                        },
+                    )
+                )
+                continue
+            if event.type == "run.resumed":
+                projected.append(
+                    (
+                        "response.resumed",
+                        {
+                            "type": "response.resumed",
+                            "response_id": invocation_id,
+                            "runId": run.id,
+                        },
+                    )
+                )
+                continue
+            if event.type == "approval.resolved":
+                # Older projections lost the top-level decision but retained
+                # the canonical response. Missing evidence is never approval.
+                runtime_response = (event.data.get("runtimeEvent") or {}).get("response") or {}
+                raw_decision = str(
+                    event.data.get("decision")
+                    or runtime_response.get("decision")
+                    or event.data.get("outcome")
+                    or event.data.get("name")
+                    or ""
+                ).strip().lower()
+                decision = _APPROVAL_DECISIONS.get(raw_decision)
+                if decision is None:
+                    # The legacy Web decoder treats any unknown decision as
+                    # approved. Retain the audit event without emitting a
+                    # resolution that this client cannot represent safely.
+                    continue
+                projected.append(
+                    (
+                        "response.ksadk.approval_resolved",
+                        {
+                            "type": "response.ksadk.approval_resolved",
+                            "approvalRequestId": event.data.get("approvalId")
+                            or event.data.get("interactionId"),
+                            "decision": decision,
+                            "revision": event.data.get("revision") or 2,
+                            "runId": run.id,
+                        },
+                    )
+                )
+                continue
+            item_event = self._response_item_event(event.type, event.data, starts)
+            if item_event is not None:
+                projected.append(item_event)
+    return projected

ksadk/studio/shared_web_run_state.py

@@ -0,0 +1,133 @@
+"""Durable run-state helpers shared by Studio's web protocol bridge."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Mapping
+from typing import Any
+
+from ksadk.studio.contracts import OperationStatus, RunStatus
+from ksadk.studio.errors import StudioError
+
+
+def resolve_cancel_run_id(
+    studio: Any,
+    invocation_id: str,
+    run_ids: Mapping[str, str],
+    response_runs: Mapping[str, str],
+) -> str | None:
+    run_id = run_ids.get(invocation_id) or response_runs.get(invocation_id)
+    if run_id:
+        return run_id
+    try:
+        studio.event_store.get(invocation_id)
+    except Exception:  # noqa: BLE001 - absence is the expected branch
+        return None
+    return invocation_id
+
+
+async def wait_for_durable_run(
+    task: asyncio.Task[Any],
+    run_ids: Mapping[str, str],
+    invocation_id: str,
+    operations: Mapping[str, str] | None = None,
+) -> None:
+    # A next-turn prompt may remain queued behind the active Run. Its durable
+    # Operation is enough to acknowledge the request before a Run ID exists.
+    while (
+        invocation_id not in run_ids
+        and (operations is None or invocation_id not in operations)
+        and not task.done()
+    ):
+        await asyncio.sleep(0.01)
+    if invocation_id not in run_ids and (operations is None or invocation_id not in operations):
+        await task
+
+
+def release_operation(
+    task: asyncio.Task[Any], operations: dict[str, str], invocation_id: str
+) -> None:
+    operations.pop(invocation_id, None)
+    if not task.cancelled():
+        task.exception()
+
+
+def attach_release_callback(
+    task: asyncio.Task[Any], operations: dict[str, str], invocation_id: str
+) -> None:
+    task.add_done_callback(lambda done: release_operation(done, operations, invocation_id))
+
+
+def created_response_sse(
+    invocation_id: str, *, model: str, encode: Any, response_shell: Any
+) -> str:
+    return encode(
+        "response.created",
+        {
+            "type": "response.created",
+            "response": response_shell(invocation_id, model=model),
+        },
+    )
+
+
+def raise_for_unsuccessful_operation(studio: Any, operation: Any) -> None:
+    if operation.status == OperationStatus.CANCELLED:
+        raise StudioError("RUN_CANCELLED", "运行已取消", status_code=409)
+    try:
+        run = studio.event_store.get(operation.resource_id)
+    except Exception:  # noqa: BLE001 - preserve the operation error below
+        run = None
+    if run is not None and run.status == RunStatus.CANCELLED:
+        raise StudioError("RUN_CANCELLED", "运行已取消", status_code=409)
+    message = str((operation.error or {}).get("message") or "Agent 运行失败")
+    raise StudioError("RUN_FAILED", message, status_code=500)
+
+
+def cancelled_response_sse(invocation_id: str, *, encode: Any) -> str:
+    return encode(
+        "response.cancelled",
+        {
+            "type": "response.cancelled",
+            "response": {"id": invocation_id, "status": "cancelled"},
+        },
+    )
+
+
+def control_ready_event(studio, run_id: str, invocation_id: str):
+    """Publish control admission only after the Runtime owner is attached."""
+    handle = studio.run_service._active_handles.get(run_id)
+    if handle is None or not studio.run_service.executor.is_attached(handle):
+        return None
+    record = studio.event_store.get(run_id)
+    if record.status != RunStatus.RUNNING:
+        return None
+    payload: dict[str, Any] = {
+        "InvocationId": invocation_id,
+        "RunId": record.id,
+        "AgentId": record.agent_id,
+        "SessionId": record.session_id,
+    }
+    matrix = studio.run_service.executor.attached_capabilities(handle)
+    if any(value is not None for value in (matrix.child_input, matrix.child_promotion,
+                                           matrix.child_cancellation)):
+        payload["ChildControls"] = {
+            "input": bool(matrix.child_input and matrix.child_input.supported),
+            "promotion": bool(matrix.child_promotion and matrix.child_promotion.supported),
+        }
+        if matrix.child_cancellation is not None:
+            payload["ChildControls"]["cancellation"] = matrix.child_cancellation.supported
+    return "studio.run.control_ready", payload
+
+
+def response_shell(response_id: str, *, model: str) -> dict[str, Any]:
+    return {
+        "id": response_id,
+        "object": "response",
+        "status": "in_progress",
+        "model": model,
+        "output": [],
+    }
+
+
+def resolve_run_reference(run_ids, response_runs, reference: str) -> str:
+    return run_ids.get(reference) or response_runs.get(reference) or reference

ksadk/studio/skill_discovery.py

@@ -8,11 +8,15 @@ import os
 import re
 import shutil
 import stat
+import zipfile
 from datetime import datetime, timezone
-from pathlib import Path
+from io import BytesIO
+from pathlib import Path, PurePosixPath
 from typing import Any, cast
+from urllib.parse import quote
 from uuid import uuid4
 
+import httpx
 import yaml  # type: ignore[import-untyped]
 
 from ksadk.studio.capabilities import canonical_json, require_exact_version, sha256_digest
@@ -22,6 +26,9 @@ from ksadk.studio.workspace import Workspace
 MAX_SKILL_BYTES = 100 * 1024 * 1024
 MAX_SKILL_FILES = 1000
 MAX_PREVIEW_BYTES = 512 * 1024
+MAX_REMOTE_ARCHIVE_BYTES = 50 * 1024 * 1024
+MAX_REMOTE_ARCHIVE_FILES = 5000
+MAX_REMOTE_UNPACKED_BYTES = 200 * 1024 * 1024
 SCRIPT_SUFFIXES = frozenset({".py", ".sh", ".js", ".ts", ".tsx", ".ps1", ".rb"})
 TEXT_SUFFIXES = frozenset(
     {".md", ".txt", ".yaml", ".yml", ".json", ".toml", ".ini", ".cfg", ".css", ".html", ".xml"}
@@ -106,6 +113,134 @@ class SkillDiscoveryService:
         )
         return record
 
+    def discover_github(self, source_url: str, *, ref: str = "main") -> dict[str, Any]:
+        """Inspect Agent Skills from one GitHub repository without executing it.
+
+        The mutable branch name is resolved to a commit SHA before downloading.
+        Installation remains a separate, explicit commit step so model output
+        can never turn an arbitrary public repository into executable host code.
+        """
+
+        owner, repository = self._github_repository(source_url)
+        requested_ref = self._github_ref(ref)
+        headers = {
+            "Accept": "application/vnd.github+json",
+            "User-Agent": "ksadk-studio-skill-inspector/1",
+            "X-GitHub-Api-Version": "2022-11-28",
+        }
+        try:
+            with httpx.Client(timeout=20, follow_redirects=True, headers=headers) as client:
+                commit_sha = (
+                    requested_ref.lower()
+                    if re.fullmatch(r"[0-9a-fA-F]{40}", requested_ref)
+                    else self._resolve_github_commit(
+                        client,
+                        owner=owner,
+                        repository=repository,
+                        requested_ref=requested_ref,
+                    )
+                )
+                if not re.fullmatch(r"[0-9a-f]{40}", commit_sha):
+                    raise ValueError("GitHub response omitted an immutable commit SHA")
+                content = self._download_remote_archive(
+                    client,
+                    f"https://codeload.github.com/{owner}/{repository}/zip/{commit_sha}",
+                )
+        except (httpx.HTTPError, ValueError) as exc:
+            raise StudioError(
+                "SKILL_REMOTE_FETCH_FAILED",
+                "无法读取 GitHub Skill 仓库，请检查地址、版本和网络连接",
+                status_code=422,
+                details={
+                    "source": f"https://github.com/{owner}/{repository}",
+                    "ref": requested_ref,
+                },
+            ) from exc
+        token = f"skd_{uuid4().hex}"
+        cache_root = self._remote_cache_root(token)
+        try:
+            self._extract_remote_archive(content, cache_root)
+            manifests = self._scan_manifests(cache_root)
+            candidates = [
+                self.inspect_candidate(
+                    manifest.parent,
+                    source="remote-github",
+                    root=cache_root,
+                    display_root=f"github:{owner}/{repository}@{commit_sha[:12]}",
+                )
+                for manifest in sorted(set(manifests), key=lambda item: item.as_posix())
+            ]
+            candidates.sort(key=lambda item: (item.get("name", ""), item["path"]))
+            record = {
+                "format": "agentkit.skill-discovery/v1",
+                "inspectionToken": token,
+                "source": {
+                    "kind": "github",
+                    "url": f"https://github.com/{owner}/{repository}",
+                    "requestedRef": requested_ref,
+                    "commitSha": commit_sha,
+                },
+                "candidates": candidates,
+                "requiresConfirmation": True,
+            }
+            self.workspace.atomic_write_text(
+                self._record_path(token),
+                json.dumps(record, ensure_ascii=False, sort_keys=True, indent=2) + "\n",
+            )
+        except Exception:
+            shutil.rmtree(cache_root, ignore_errors=True)
+            raise
+        return record
+
+    @staticmethod
+    def _resolve_github_commit(
+        client: httpx.Client,
+        *,
+        owner: str,
+        repository: str,
+        requested_ref: str,
+    ) -> str:
+        """Resolve a mutable GitHub ref without making REST rate limits fatal.
+
+        The REST endpoint remains preferred.  Public GitHub egress often
+        shares one unauthenticated REST quota, however, while the repository's
+        read-only Git advertisement is still available.  That advertisement
+        contains only ref names and immutable object IDs; parsing it neither
+        executes repository content nor weakens the later archive checks.
+        """
+
+        try:
+            revision = client.get(
+                "https://api.github.com/repos/"
+                f"{owner}/{repository}/commits/{quote(requested_ref, safe='')}"
+            )
+            revision.raise_for_status()
+            payload = revision.json()
+            commit_sha = str(payload.get("sha") or "").lower()
+            if re.fullmatch(r"[0-9a-f]{40}", commit_sha):
+                return commit_sha
+        except (httpx.HTTPError, ValueError):
+            pass
+
+        advertised = client.get(
+            f"https://github.com/{owner}/{repository}.git/info/refs?service=git-upload-pack"
+        )
+        advertised.raise_for_status()
+        content = bytes(advertised.content)
+        if len(content) > 5 * 1024 * 1024:
+            raise ValueError("Git ref advertisement exceeds size limit")
+        escaped = re.escape(requested_ref.encode("utf-8"))
+        candidates = (
+            rb"([0-9a-f]{40}) refs/tags/" + escaped + rb"\^\{}(?:\x00|\n)",
+            rb"([0-9a-f]{40}) refs/heads/" + escaped + rb"(?:\x00|\n)",
+            rb"([0-9a-f]{40}) refs/tags/" + escaped + rb"(?:\x00|\n)",
+        )
+        for pattern in candidates:
+            match = re.search(pattern, content)
+            if match is not None:
+                return match.group(1).decode("ascii")
+        raise ValueError("GitHub ref advertisement omitted the requested ref")
+
     def commit(
         self,
         inspection_token: str,
@@ -144,7 +279,7 @@ class SkillDiscoveryService:
                 details={"candidateId": candidate_id},
             )
         source, source_kind, source_root, display_root = self._resolve_candidate_directory(
-            candidate
+            candidate, inspection_token=inspection_token
         )
         current = self.inspect_candidate(
             source,
@@ -215,6 +350,7 @@ class SkillDiscoveryService:
             )
         else:
             record_path.unlink(missing_ok=True)
+            shutil.rmtree(self._remote_cache_root(inspection_token), ignore_errors=True)
         return slug, str(candidate["version"])
 
     def preview_candidate(
@@ -225,9 +361,20 @@ class SkillDiscoveryService:
         path: str | None = None,
     ) -> dict[str, Any]:
         candidate = self._candidate_from_record(inspection_token, candidate_id)
-        directory, _, _, _ = self._resolve_candidate_directory(candidate)
+        directory, _, _, _ = self._resolve_candidate_directory(
+            candidate, inspection_token=inspection_token
+        )
         return self.preview_directory(directory, path=path)
 
+    def discard(self, inspection_token: str) -> None:
+        """Discard an uncommitted inspection and any downloaded remote bytes."""
+
+        record_path = self._record_path(inspection_token, validate=True)
+        if not record_path.exists():
+            return
+        record_path.unlink(missing_ok=True)
+        shutil.rmtree(self._remote_cache_root(inspection_token), ignore_errors=True)
+
     def preview_directory(
         self,
         directory: Path,
@@ -474,12 +621,30 @@ class SkillDiscoveryService:
     def _resolve_candidate_directory(
         self,
         candidate: dict[str, Any],
+        *,
+        inspection_token: str | None = None,
     ) -> tuple[Path, str, Path, str]:
         source = str(candidate.get("source") or "workspace")
         relative = str(candidate.get("relativePath") or candidate.get("path") or "")
         if source == "workspace":
             directory = self.workspace.resolve(relative, must_exist=True)
             return directory, source, self.workspace.root, ""
+        if source == "remote-github":
+            if inspection_token is None:
+                raise StudioError(
+                    "SKILL_DISCOVERY_NOT_FOUND",
+                    "远程 Skill 候选缺少发现记录",
+                    status_code=404,
+                )
+            root = self._remote_cache_root(inspection_token, validate=True)
+            directory = (root / relative).resolve(strict=True)
+            if not directory.is_relative_to(root):
+                raise StudioError(
+                    "SKILL_DISCOVERY_PATH_FORBIDDEN",
+                    "远程 Skill 候选路径越界",
+                    status_code=403,
+                )
+            return directory, source, root, "remote-github"
         configured = self._user_skill_roots().get(source)
         if configured is None:
             raise StudioError(
@@ -507,6 +672,8 @@ class SkillDiscoveryService:
     def _candidate_relative(self, directory: Path, *, source: str, root: Path) -> str:
         if source == "workspace":
             return self.workspace.relative(directory)
+        if source == "remote-github":
+            return directory.resolve().relative_to(root.resolve()).as_posix()
         configured = self._user_skill_roots().get(source)
         source_root = configured[0] if configured is not None else root
         try:
@@ -624,5 +791,140 @@ class SkillDiscoveryService:
             )
         return self.workspace.resolve(Path(".agentkit/skill-discoveries") / f"{token}.json")
 
+    def _remote_cache_root(self, token: str, *, validate: bool = False) -> Path:
+        if validate and not re.fullmatch(r"skd_[0-9a-f]{32}", token):
+            raise StudioError(
+                "SKILL_DISCOVERY_NOT_FOUND",
+                "Skill 发现记录不存在或已失效",
+                status_code=404,
+            )
+        return self.workspace.resolve(Path(".agentkit/skill-discoveries-cache") / token)
+
+    @staticmethod
+    def _github_repository(source_url: str) -> tuple[str, str]:
+        match = re.fullmatch(
+            r"https://github\.com/([A-Za-z0-9_.-]{1,100})/([A-Za-z0-9_.-]{1,100})(?:\.git)?/?",
+            source_url.strip(),
+        )
+        if not match:
+            raise StudioError(
+                "SKILL_REMOTE_SOURCE_INVALID",
+                "仅支持 https://github.com/<owner>/<repo> 仓库地址",
+                status_code=422,
+            )
+        owner, repository = match.groups()
+        return owner, repository.removesuffix(".git")
+
+    @staticmethod
+    def _github_ref(ref: str) -> str:
+        value = ref.strip()
+        if (
+            not value
+            or len(value) > 128
+            or value.startswith("/")
+            or ".." in value.split("/")
+            or not re.fullmatch(r"[A-Za-z0-9._/-]+", value)
+        ):
+            raise StudioError(
+                "SKILL_REMOTE_REF_INVALID",
+                "GitHub 版本必须是安全的分支、标签或 commit",
+                status_code=422,
+            )
+        return value
+
+    def _extract_remote_archive(self, content: bytes, destination: Path) -> None:
+        try:
+            archive = zipfile.ZipFile(BytesIO(content))
+        except (zipfile.BadZipFile, OSError) as exc:
+            raise StudioError(
+                "SKILL_REMOTE_ARCHIVE_INVALID",
+                "GitHub Skill 仓库不是有效 ZIP",
+                status_code=422,
+            ) from exc
+        with archive:
+            files = [item for item in archive.infolist() if not item.is_dir()]
+            if not files or len(files) > MAX_REMOTE_ARCHIVE_FILES:
+                raise StudioError(
+                    "SKILL_REMOTE_ARCHIVE_TOO_LARGE",
+                    "GitHub Skill 仓库文件数超限",
+                    status_code=422,
+                )
+            roots: set[str] = set()
+            unpacked = 0
+            safe_entries: list[tuple[zipfile.ZipInfo, PurePosixPath]] = []
+            for info in files:
+                path = PurePosixPath(info.filename)
+                mode = (info.external_attr >> 16) & 0o170000
+                if (
+                    path.is_absolute()
+                    or len(path.parts) < 2
+                    or ".." in path.parts
+                    or "\\" in info.filename
+                    or any(":" in part for part in path.parts)
+                    or mode == stat.S_IFLNK
+                    or (info.compress_size == 0 and info.file_size > 0)
+                    or (info.compress_size > 0 and info.file_size / info.compress_size > 200)
+                ):
+                    raise StudioError(
+                        "SKILL_REMOTE_ARCHIVE_UNSAFE",
+                        "GitHub Skill 仓库包含不安全路径、链接或压缩条目",
+                        status_code=422,
+                        details={"entry": info.filename},
+                    )
+                roots.add(path.parts[0])
+                unpacked += info.file_size
+                if unpacked > MAX_REMOTE_UNPACKED_BYTES:
+                    raise StudioError(
+                        "SKILL_REMOTE_ARCHIVE_TOO_LARGE",
+                        "GitHub Skill 仓库解压后超过 200 MiB 上限",
+                        status_code=422,
+                    )
+                relative = PurePosixPath(*path.parts[1:])
+                if any(part in EXCLUDED_PARTS for part in relative.parts):
+                    continue
+                safe_entries.append((info, relative))
+            if len(roots) != 1:
+                raise StudioError(
+                    "SKILL_REMOTE_ARCHIVE_UNSAFE",
+                    "GitHub Skill 仓库缺少唯一根目录",
+                    status_code=422,
+                )
+            destination.mkdir(parents=True, exist_ok=False)
+            for info, relative in safe_entries:
+                target = destination / Path(*relative.parts)
+                target.parent.mkdir(parents=True, exist_ok=True)
+                target.write_bytes(archive.read(info))
+
+    @staticmethod
+    def _download_remote_archive(client: httpx.Client, url: str) -> bytes:
+        """Download a remote archive without allowing an oversized body in memory."""
+
+        chunks: list[bytes] = []
+        total = 0
+        with client.stream("GET", url) as response:
+            response.raise_for_status()
+            content_length = response.headers.get("content-length")
+            if content_length:
+                try:
+                    declared_size = int(content_length)
+                except ValueError:
+                    declared_size = 0
+                if declared_size > MAX_REMOTE_ARCHIVE_BYTES:
+                    raise StudioError(
+                        "SKILL_REMOTE_ARCHIVE_TOO_LARGE",
+                        "GitHub Skill 仓库压缩包超过 50 MiB 上限",
+                        status_code=422,
+                    )
+            for chunk in response.iter_bytes():
+                total += len(chunk)
+                if total > MAX_REMOTE_ARCHIVE_BYTES:
+                    raise StudioError(
+                        "SKILL_REMOTE_ARCHIVE_TOO_LARGE",
+                        "GitHub Skill 仓库压缩包超过 50 MiB 上限",
+                        status_code=422,
+                    )
+                chunks.append(chunk)
+        return b"".join(chunks)
+
 
 __all__ = ["SkillDiscoveryService"]