agentengine-sdk-python 0.8.3__py3-none-any.whl → 0.8.5__py3-none-any.whl

ksadk/skills/models.py

@@ -76,6 +76,17 @@ class SkillRef:
     def is_active(self) -> bool:
         return not self.status or self.status.lower() in {"active", "available", "enabled"}
 
+    def matches_execution_identity(self, other: "SkillRef") -> bool:
+        """Match the immutable Skill version, not mutable display metadata."""
+
+        if not self.skill_id or not self.version_id:
+            return False
+        if (self.skill_id, self.version_id) != (other.skill_id, other.version_id):
+            return False
+        return not (
+            self.content_hash and other.content_hash
+        ) or self.content_hash == other.content_hash
+
 
 @dataclass(frozen=True)
 class SkillListResponse:
@@ -85,6 +96,10 @@ class SkillListResponse:
     skills: list[SkillRef]
     code: int = 0
     message: str = ""
+    total_count: int | None = None
+    truncated: bool = False
+    next_page: int | None = None
+    pagination_warning: str = ""
 
     @classmethod
     def from_payload(
@@ -94,10 +109,24 @@ class SkillListResponse:
         space_id: str = "",
         space_name: str = "",
     ) -> "SkillListResponse":
-        data = payload.get("Data") or payload.get("data") or {}
-        skills_payload = (
-            data.get("Skills") or data.get("skills") or data.get("Items") or data.get("items") or []
+        data = payload.get("Data", payload.get("data", {}))
+        if not isinstance(data, dict):
+            raise ValueError("Skill directory response must contain an object")
+        skills_payload = next(
+            (data[key] for key in ("Skills", "skills", "Items", "items") if key in data), []
         )
+        if skills_payload is None:
+            skills_payload = []
+        if not isinstance(skills_payload, list) or any(
+            not isinstance(item, dict) for item in skills_payload
+        ):
+            raise ValueError("Skill directory items must be objects")
+        total = data.get("TotalCount", data.get("total_count", payload.get("TotalCount")))
+        if total is not None:
+            if isinstance(total, str) and total.isdigit():
+                total = int(total)
+            if type(total) is not int or total < 0:
+                raise ValueError("Skill directory total count is invalid")
         return cls(
             code=int(payload.get("Code") or payload.get("code") or 0),
             message=str(payload.get("Message") or payload.get("message") or ""),
@@ -109,9 +138,13 @@ class SkillListResponse:
             skills=[
                 SkillRef.from_payload(item) for item in skills_payload if isinstance(item, dict)
             ],
+            total_count=total,
         )
 
-    def active_skills(self) -> list[SkillRef]:
+    def active_skills(self, *, allow_partial: bool = False) -> list[SkillRef]:
+        """Require callers consuming a partial directory to acknowledge it."""
+        if self.truncated and not allow_partial:
+            raise ValueError("Skill directory is incomplete; refresh or continue pagination")
         return [skill for skill in self.skills if skill.is_active]
 
 

ksadk/skills/observability.py

@@ -0,0 +1,132 @@
+"""OTEL projection for typed Skill Runtime facts."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any
+
+from ksadk.skills.events import SkillEvent
+
+_LIFECYCLE_STARTS = {
+    "skill.load.started": "skill.load",
+    "skill.execution.started": "skill.execution",
+    "sandbox.session.created": "sandbox.session",
+}
+_LIFECYCLE_ENDS = {
+    "skill.load.completed": "skill.load",
+    "skill.load.failed": "skill.load",
+    "skill.execution.completed": "skill.execution",
+    "skill.execution.failed": "skill.execution",
+    "sandbox.session.cleaned_up": "sandbox.session",
+    "sandbox.session.cleanup_failed": "sandbox.session",
+}
+
+
+def project_skill_events(events: Iterable[SkillEvent], *, tracer: Any | None = None) -> None:
+    """Project facts beneath the current tool span without affecting execution."""
+
+    try:
+        from opentelemetry import trace
+        from opentelemetry.trace import Status, StatusCode
+
+        active_tracer = tracer or trace.get_tracer("ksadk.skills")
+        parent = trace.get_current_span()
+        lifecycle_starts: dict[tuple[str, str], SkillEvent] = {}
+        for event in events:
+            attributes = _span_attributes(event)
+            lifecycle = _LIFECYCLE_STARTS.get(event.event_type)
+            if lifecycle:
+                lifecycle_starts[(lifecycle, _lifecycle_id(event))] = event
+                continue
+            lifecycle = _LIFECYCLE_ENDS.get(event.event_type)
+            if lifecycle:
+                start = lifecycle_starts.pop((lifecycle, _lifecycle_id(event)), event)
+                _project_span(
+                    active_tracer,
+                    event,
+                    attributes,
+                    start.started_at,
+                    event.started_at,
+                    Status,
+                    StatusCode,
+                )
+            elif event.ended_at is not None:
+                _project_span(
+                    active_tracer,
+                    event,
+                    attributes,
+                    event.started_at,
+                    event.ended_at,
+                    Status,
+                    StatusCode,
+                )
+            elif parent.is_recording():
+                parent.add_event(
+                    event.event_type,
+                    attributes=attributes,
+                    timestamp=_nanoseconds(event.started_at),
+                )
+    except Exception:
+        return
+
+
+def _project_span(
+    tracer: Any,
+    event: SkillEvent,
+    attributes: dict[str, str | int | float | bool | list[str]],
+    started_at: float,
+    ended_at: float,
+    Status: Any,
+    StatusCode: Any,
+) -> None:
+    span = tracer.start_span(event.event_type, start_time=_nanoseconds(started_at))
+    for key, value in attributes.items():
+        span.set_attribute(key, value)
+    if event.status in {"failed", "timeout", "timed_out", "cleanup_failed"}:
+        span.set_status(Status(StatusCode.ERROR, event.error_category or event.status))
+    span.end(end_time=_nanoseconds(ended_at))
+
+
+def _lifecycle_id(event: SkillEvent) -> str:
+    return event.skill_invocation_id or event.runtime_id
+
+
+def _span_attributes(event: SkillEvent) -> dict[str, str | int | float | bool | list[str]]:
+    attributes: dict[str, str | int | float | bool | list[str]] = {
+        "ksadk.skill.event_type": event.event_type,
+        "ksadk.skill.status": event.status,
+    }
+    for name, value in (
+        ("event_id", event.event_id),
+        ("invocation_id", event.skill_invocation_id),
+        ("runtime_id", event.runtime_id),
+        ("run_id", event.run_id),
+        ("binding_snapshot_id", event.binding_snapshot_id),
+        ("decision_id", event.decision_id),
+        ("error_code", event.error_code),
+        ("error_category", event.error_category),
+    ):
+        if value:
+            attributes[f"ksadk.skill.{name}"] = value
+    if event.skill_ref is not None:
+        attributes["ksadk.skill.id"] = event.skill_ref.skill_id
+        attributes["ksadk.skill.version_id"] = event.skill_ref.version_id
+        attributes["ksadk.skill.version"] = event.skill_ref.version
+        attributes["ksadk.skill.name"] = event.skill_ref.name
+    for key, value in event.attributes.items():
+        normalized = _attribute_value(value)
+        if normalized is not None:
+            attributes[f"ksadk.skill.{key}"] = normalized
+    return attributes
+
+
+def _attribute_value(value: Any) -> str | int | float | bool | list[str] | None:
+    if isinstance(value, (str, int, float, bool)):
+        return value
+    if isinstance(value, (list, tuple)) and all(isinstance(item, str) for item in value):
+        return list(value)
+    return None
+
+
+def _nanoseconds(timestamp: float) -> int:
+    return int(timestamp * 1_000_000_000)

ksadk/skills/package_store.py

@@ -1,11 +1,24 @@
 from __future__ import annotations
 
 import hashlib
+import json
+import os
 import shutil
+import stat
+import tempfile
+import threading
+import time
 import zipfile
+from contextlib import contextmanager
 from dataclasses import dataclass
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 
+try:
+    import fcntl
+except ImportError:  # Windows legacy callers retain in-process synchronization.
+    fcntl = None
+
+from ksadk.skills.events import SkillEvent, SkillEventSink
 from ksadk.skills.models import SkillRef
 
 
@@ -23,60 +36,174 @@ class SkillPackage:
 
 
 class PackageStore:
-    def __init__(self, cache_dir: str | Path):
+    def __init__(
+        self,
+        cache_dir: str | Path,
+        *,
+        namespace: str = "",
+        require_hash: bool = False,
+        max_archive_bytes: int = 20 * 1024 * 1024,
+        max_extracted_bytes: int = 100 * 1024 * 1024,
+        max_files: int = 2000,
+    ):
+        if any(
+            type(value) is not int or value < 1
+            for value in (max_archive_bytes, max_extracted_bytes, max_files)
+        ):
+            raise ValueError("Skill package limits must be positive integers")
+        if require_hash and (not namespace or fcntl is None):
+            raise ValueError("Verified package stores require a namespace and process locking")
         self.cache_dir = Path(cache_dir)
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
-
-    def store_archive(self, ref: SkillRef, content: bytes) -> SkillPackage:
-        self._verify_hash(ref, content)
-        skill_dir = self._skill_dir(ref)
-        archive_path = skill_dir / "archive.zip"
-        extract_dir = skill_dir / "extracted"
-
-        if archive_path.exists() and extract_dir.exists():
-            cached = self.get_cached(ref)
-            if cached is not None:
-                return cached
-
-        if skill_dir.exists():
-            shutil.rmtree(skill_dir)
-        skill_dir.mkdir(parents=True, exist_ok=True)
-        archive_path.write_bytes(content)
-        extract_dir.mkdir(parents=True, exist_ok=True)
-        self._safe_extract(archive_path, extract_dir)
+        self.cache_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
+        self.namespace = namespace
+        self.require_hash = require_hash
+        self.max_archive_bytes = max_archive_bytes
+        self.max_extracted_bytes = max_extracted_bytes
+        self.max_files = max_files
+        self._thread_lock = threading.RLock()
 
-        return SkillPackage(
+    def store_archive(
+        self,
+        ref: SkillRef,
+        content: bytes,
+        *,
+        event_sink: SkillEventSink | None = None,
+        skill_invocation_id: str = "",
+    ) -> SkillPackage:
+        hash_started_at = time.time()
+        try:
+            self._verify_hash(ref, content)
+        except SkillPackageError:
+            self._emit_lifecycle(
+                event_sink,
+                "skill.package.hash_verified",
+                status="failed",
+                ref=ref,
+                skill_invocation_id=skill_invocation_id,
+                started_at=hash_started_at,
+                error_category="hash_verification_failed",
+            )
+            raise
+        self._emit_lifecycle(
+            event_sink,
+            "skill.package.hash_verified",
+            status="completed",
             ref=ref,
-            archive_path=archive_path,
-            extract_dir=extract_dir,
-            root_dir=self._find_skill_root(extract_dir),
-            cache_hit=False,
+            skill_invocation_id=skill_invocation_id,
+            started_at=hash_started_at,
         )
+        with self._locked(ref):
+            cached = self._get_cached(ref)
+            if cached is not None:
+                return cached
+            skill_dir = self._skill_dir(ref)
+            stage = Path(tempfile.mkdtemp(prefix=".stage-", dir=self.cache_dir))
+            extract_started_at = time.time()
+            try:
+                (stage / "archive.zip").write_bytes(content)
+                os.chmod(stage / "archive.zip", 0o600)
+                extracted = stage / "extracted"
+                extracted.mkdir(mode=0o700)
+                self._safe_extract(stage / "archive.zip", extracted)
+                self._find_skill_root(extracted)
+                # Publish only a complete validated tree, under the per-key lock.
+                if skill_dir.is_symlink() or skill_dir.is_file():
+                    skill_dir.unlink()
+                elif skill_dir.exists():
+                    shutil.rmtree(skill_dir)
+                os.replace(stage, skill_dir)
+            except (OSError, zipfile.BadZipFile, RuntimeError, ValueError) as error:
+                self._emit_lifecycle(
+                    event_sink,
+                    "skill.package.extracted",
+                    status="failed",
+                    ref=ref,
+                    skill_invocation_id=skill_invocation_id,
+                    started_at=extract_started_at,
+                    error_category="extract_failed",
+                )
+                raise SkillPackageError("Skill archive could not be safely materialized") from error
+            finally:
+                if stage.exists():
+                    shutil.rmtree(stage)
+            self._emit_lifecycle(
+                event_sink,
+                "skill.package.extracted",
+                status="completed",
+                ref=ref,
+                skill_invocation_id=skill_invocation_id,
+                started_at=extract_started_at,
+            )
+            return self._package(ref, skill_dir, cache_hit=False)
 
     def get_cached(self, ref: SkillRef) -> SkillPackage | None:
+        with self._locked(ref):
+            return self._get_cached(ref)
+
+    def _get_cached(self, ref: SkillRef) -> SkillPackage | None:
         skill_dir = self._skill_dir(ref)
         archive_path = skill_dir / "archive.zip"
         extract_dir = skill_dir / "extracted"
-        if not archive_path.exists() or not extract_dir.exists():
+        if (
+            skill_dir.is_symlink()
+            or archive_path.is_symlink()
+            or extract_dir.is_symlink()
+            or not archive_path.is_file()
+            or not extract_dir.is_dir()
+        ):
             return None
-        content = archive_path.read_bytes()
         try:
+            if archive_path.stat().st_size > self.max_archive_bytes:
+                return None
+            content = archive_path.read_bytes()
             self._verify_hash(ref, content)
-        except SkillPackageError:
+            self._verify_tree(archive_path, extract_dir)
+            return self._package(ref, skill_dir, cache_hit=True)
+        except (RuntimeError, OSError, zipfile.BadZipFile, ValueError):
             return None
+
+    def _package(self, ref: SkillRef, skill_dir: Path, *, cache_hit: bool) -> SkillPackage:
         return SkillPackage(
             ref=ref,
-            archive_path=archive_path,
-            extract_dir=extract_dir,
-            root_dir=self._find_skill_root(extract_dir),
-            cache_hit=True,
+            archive_path=skill_dir / "archive.zip",
+            extract_dir=skill_dir / "extracted",
+            root_dir=self._find_skill_root(skill_dir / "extracted"),
+            cache_hit=cache_hit,
         )
 
     def _skill_dir(self, ref: SkillRef) -> Path:
-        return self.cache_dir / (ref.cache_key or ref.name or "skill")
+        identity = [
+            self.namespace,
+            ref.skill_id,
+            ref.version_id,
+            ref.version,
+            ref.name,
+            ref.content_hash.render() if ref.content_hash else "",
+        ]
+        key = hashlib.sha256(json.dumps(identity, ensure_ascii=False).encode()).hexdigest()
+        return self.cache_dir / key
+
+    @contextmanager
+    def _locked(self, ref: SkillRef):
+        with self._thread_lock:
+            if fcntl is None:
+                yield
+                return
+            path = self._skill_dir(ref).with_suffix(".lock")
+            fd = os.open(path, os.O_CREAT | os.O_RDWR | os.O_NOFOLLOW, 0o600)
+            with os.fdopen(fd, "rb") as lock:
+                fcntl.flock(lock, fcntl.LOCK_EX)
+                try:
+                    yield
+                finally:
+                    fcntl.flock(lock, fcntl.LOCK_UN)
 
     def _verify_hash(self, ref: SkillRef, content: bytes) -> None:
+        if len(content) > self.max_archive_bytes:
+            raise SkillPackageError("Skill archive exceeds size limit")
         if not ref.content_hash:
+            if self.require_hash:
+                raise SkillPackageError("Verified Skill packages require ContentHash")
             return
         if ref.content_hash.algorithm != "sha256":
             raise SkillPackageError(
@@ -90,13 +217,82 @@ class PackageStore:
             )
 
     def _safe_extract(self, archive_path: Path, extract_dir: Path) -> None:
-        base = extract_dir.resolve()
+        expanded = 0
         with zipfile.ZipFile(archive_path) as archive:
-            for member in archive.infolist():
-                target = (extract_dir / member.filename).resolve()
-                if not str(target).startswith(str(base) + "/") and target != base:
-                    raise SkillPackageError(f"unsafe zip member: {member.filename}")
-            archive.extractall(extract_dir)
+            for member, relative in self._members(archive):
+                target = extract_dir / relative
+                target.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+                if member.is_dir():
+                    target.mkdir(exist_ok=True, mode=0o700)
+                    continue
+                with archive.open(member) as source, target.open("xb") as destination:
+                    written = 0
+                    while chunk := source.read(64 * 1024):
+                        written += len(chunk)
+                        expanded += len(chunk)
+                        if written > member.file_size or expanded > self.max_extracted_bytes:
+                            raise SkillPackageError("Expanded Skill package exceeds limits")
+                        destination.write(chunk)
+                os.chmod(target, 0o700 if (member.external_attr >> 16) & 0o111 else 0o600)
+
+    def _members(self, archive: zipfile.ZipFile):
+        members = archive.infolist()
+        if (
+            len(members) > self.max_files
+            or sum(item.file_size for item in members) > self.max_extracted_bytes
+        ):
+            raise SkillPackageError("Expanded Skill package exceeds limits")
+        seen = set()
+        result = []
+        for member in members:
+            relative = PurePosixPath(member.filename)
+            kind = stat.S_IFMT(member.external_attr >> 16)
+            if (
+                not relative.parts
+                or relative.is_absolute()
+                or ".." in relative.parts
+                or "\\" in member.filename
+                or ":" in member.filename
+                or "\x00" in member.orig_filename
+                or kind not in (0, stat.S_IFREG, stat.S_IFDIR)
+                or relative in seen
+                or member.flag_bits & 1
+            ):
+                raise SkillPackageError("Unsafe Skill archive member")
+            seen.add(relative)
+            result.append((member, relative))
+        return result
+
+    def _verify_tree(self, archive_path: Path, extract_dir: Path) -> None:
+        expected = set()
+        with zipfile.ZipFile(archive_path) as archive:
+            for member, relative in self._members(archive):
+                expected.update(
+                    parent for parent in relative.parents if parent != PurePosixPath(".")
+                )
+                expected.add(relative)
+                target = extract_dir / relative
+                if any((extract_dir / parent).is_symlink() for parent in relative.parents):
+                    raise SkillPackageError("Skill cache contains a linked parent")
+                if target.is_symlink():
+                    raise SkillPackageError("Skill cache contains a link")
+                if member.is_dir():
+                    if not target.is_dir():
+                        raise SkillPackageError("Skill cache directory missing")
+                    continue
+                if not target.is_file() or target.stat().st_size != member.file_size:
+                    raise SkillPackageError("Skill cache file changed")
+                with archive.open(member) as source, target.open("rb") as current:
+                    while chunk := source.read(64 * 1024):
+                        if chunk != current.read(len(chunk)):
+                            raise SkillPackageError("Skill cache content changed")
+        actual = set()
+        for path in extract_dir.rglob("*"):
+            if path.is_symlink():
+                raise SkillPackageError("Skill cache contains a link")
+            actual.add(PurePosixPath(path.relative_to(extract_dir).as_posix()))
+        if actual != expected:
+            raise SkillPackageError("Skill cache file set changed")
 
     def _find_skill_root(self, extract_dir: Path) -> Path:
         if (extract_dir / "SKILL.md").exists():
@@ -105,3 +301,28 @@ class PackageStore:
         if not candidates:
             raise SkillPackageError(f"SKILL.md not found under {extract_dir}")
         return candidates[0]
+
+    @staticmethod
+    def _emit_lifecycle(
+        event_sink: SkillEventSink | None,
+        event_type: str,
+        *,
+        status: str,
+        ref: SkillRef,
+        skill_invocation_id: str,
+        started_at: float,
+        error_category: str = "",
+    ) -> None:
+        if event_sink is None or not skill_invocation_id:
+            return
+        event_sink.emit(
+            SkillEvent.create(
+                event_type,
+                status=status,
+                skill_ref=ref,
+                skill_invocation_id=skill_invocation_id,
+                started_at=started_at,
+                ended_at=time.time(),
+                error_category=error_category,
+            )
+        )

ksadk/skills/runtime/agent.py

@@ -8,11 +8,13 @@ from pathlib import Path
 
 import httpx
 
+from ksadk.skills.events import SKILL_EVENT_FILE_ENV, SkillEventSink
 from ksadk.skills.loader import LocalSkill
 from ksadk.skills.models import SkillRef
 from ksadk.skills.package_store import PackageStore
 from ksadk.skills.runtime import loader as runtime_loader
 from ksadk.skills.runtime import registry as runtime_registry
+from ksadk.skills.runtime.artifact_delivery import export_artifacts
 from ksadk.skills.runtime.base import normalize_skill_names
 from ksadk.skills.runtime.executor import (
     WorkflowExecution,
@@ -36,12 +38,18 @@ from ksadk.skills.runtime.executor import (
 from ksadk.skills.runtime.executor import (
     _tail as _executor_tail,
 )
+from ksadk.skills.runtime.pinned import (
+    PINNED_PACKAGE_PROTOCOL_VERSION as PINNED_PACKAGE_PROTOCOL_VERSION,
+)
+from ksadk.skills.runtime.pinned import load_pinned_packages
 from ksadk.skills.runtime.request import (
     SkillWorkflowRequest,
     SkillWorkflowRequestError,
     parse_workflow_request,
 )
 
+ARTIFACT_DELIVERY_PROTOCOL_VERSION = 1
+
 
 def _skill_space_ids() -> list[str]:
     return runtime_registry.skill_space_ids()
@@ -67,14 +75,18 @@ def _load_skills(
     prompt: str = "",
     skill_names: list[str] | None = None,
     service_transport: httpx.BaseTransport | None = None,
-) -> list[LocalSkill]:
+    event_sink: SkillEventSink | None = None,
+    planned_invocations: dict[str, str] | None = None,
+) -> runtime_loader.SkillLoadResult:
     result = runtime_loader.load_skills(
         prompt=prompt,
         skill_names=skill_names,
         service_transport=service_transport,
+        event_sink=event_sink,
+        planned_invocations=planned_invocations,
     )
     _SKILL_LOAD_WARNINGS.extend(result.warnings)
-    return result.skills
+    return result
 
 
 def _dedupe_skill_refs(skill_refs: list[SkillRef], *, seen_names: set[str]) -> list[SkillRef]:
@@ -126,13 +138,49 @@ def run_agent(
         return 1
 
     prompt = request.workflow_prompt
-    selected_skill_names = request.skill_names or _selected_skill_names()
-    loaded_skills = _load_skills(
-        prompt=prompt,
-        skill_names=selected_skill_names,
-        service_transport=service_transport,
+    selected_skill_names = request.skill_names
+    event_sink = SkillEventSink(os.environ.get(SKILL_EVENT_FILE_ENV))
+    planned_invocations = {
+        entry["skill_id"]: entry["skill_invocation_id"] for entry in request.invocation_plan
+    }
+    if request.pinned_packages is not None:
+        if request.package_directory is None:
+            raise SkillWorkflowRequestError("Pinned Skill delivery directory is missing")
+        loaded_skills = load_pinned_packages(request.pinned_packages, request.package_directory)
+        skill_refs = None
+        skill_invocation_ids = None
+    else:
+        selected_skill_names = selected_skill_names or _selected_skill_names()
+        load_result = _load_skills(
+            prompt=prompt,
+            skill_names=selected_skill_names,
+            service_transport=service_transport,
+            event_sink=event_sink,
+            planned_invocations=planned_invocations or None,
+        )
+        loaded_skills = load_result.skills
+        skill_refs = load_result.skill_refs
+        skill_invocation_ids = load_result.skill_invocation_ids
+    execution = _execute_workflow(
+        prompt,
+        loaded_skills,
+        selected_skill_names=selected_skill_names,
+        event_sink=event_sink,
+        skill_refs=skill_refs,
+        skill_invocation_ids=skill_invocation_ids,
     )
-    execution = _execute_workflow(prompt, loaded_skills, selected_skill_names=selected_skill_names)
+    if request.collect_artifacts and request.package_directory is not None:
+        try:
+            root = Path(os.environ.get("KSADK_SKILL_WORKDIR") or "/tmp/ksadk-skill-workflow")
+            receipt = export_artifacts(
+                execution.output_files, root, request.package_directory / "artifacts.zip"
+            )
+            execution.artifact_bundle = receipt.model_dump()
+        except Exception:
+            execution.status = "failed"
+            execution.error = "Skill artifact delivery failed"
+            execution.output_files = []
+            execution.artifacts = []
     print(f"workflow={prompt}")
     print(f"skill_spaces={','.join(_skill_space_ids())}")
     print(f"loaded_skills={','.join(skill.name for skill in loaded_skills)}")
@@ -158,8 +206,18 @@ def _execute_workflow(
     skills: list[LocalSkill],
     *,
     selected_skill_names: list[str] | None = None,
+    event_sink: SkillEventSink | None = None,
+    skill_refs: dict[str, SkillRef] | None = None,
+    skill_invocation_ids: dict[str, str] | None = None,
 ) -> WorkflowExecution:
-    return execute_workflow(prompt, skills, selected_skill_names=selected_skill_names)
+    return execute_workflow(
+        prompt,
+        skills,
+        selected_skill_names=selected_skill_names,
+        event_sink=event_sink,
+        skill_refs=skill_refs,
+        skill_invocation_ids=skill_invocation_ids,
+    )
 
 
 def _can_run_web_artifacts_builder(skill: LocalSkill, prompt: str) -> bool: