agentengine-sdk-python 0.6.9__py3-none-any.whl → 0.8.0__py3-none-any.whl

ksadk/sessions/resilient.py

@@ -0,0 +1,388 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any, Optional, cast
+
+from ksadk.sessions.base import BaseSessionService, Session, SessionEvent, SessionState
+from ksadk.sessions.in_memory import InMemorySessionService
+from ksadk.sessions.resilience import is_session_backend_failure
+
+logger = logging.getLogger(__name__)
+
+
+class ResilientSessionService(BaseSessionService):
+    """Keep live agent sessions available when durable persistence is unavailable.
+
+    The in-memory service is authoritative for the lifetime of this process. The
+    configured durable service is used as a read-through source and a best-effort
+    write-through sink. After its first failure it stays disabled until a
+    background probe confirms the durable backend is reachable again, at which
+    point it is re-enabled and an INFO log is emitted.
+    """
+
+    _probe_interval_seconds: float = 30.0
+
+    def __init__(
+        self,
+        primary: BaseSessionService,
+        fallback: InMemorySessionService | None = None,
+    ) -> None:
+        self.primary = primary
+        self.fallback = fallback or InMemorySessionService()
+        self._primary_enabled = True
+        self._hydrate_lock = asyncio.Lock()
+        self._primary_session_lock = asyncio.Lock()
+        self._primary_session_ids: set[str] = set()
+        self._probe_task: asyncio.Task[None] | None = None
+
+    @property
+    def degraded(self) -> bool:
+        return not self._primary_enabled
+
+    async def _call_primary(self, method_name: str, *args: Any, **kwargs: Any) -> tuple[bool, Any]:
+        if not self._primary_enabled:
+            return False, None
+        try:
+            method = getattr(self.primary, method_name)
+            return True, await method(*args, **kwargs)
+        except Exception as exc:
+            if not is_session_backend_failure(exc):
+                raise
+            self._disable_primary(exc)
+            return False, None
+
+    def _disable_primary(self, exc: Exception) -> None:
+        if not self._primary_enabled:
+            return
+        self._primary_enabled = False
+        logger.error(
+            "KSADK session persistence degraded; using in-memory live session: %s",
+            exc,
+            extra={
+                "session_backend_state": "degraded",
+                "session_backend": type(self.primary).__name__,
+            },
+        )
+        self._start_probe()
+
+    def _start_probe(self) -> None:
+        if self._probe_task is not None and not self._probe_task.done():
+            return
+        self._probe_task = asyncio.create_task(self._probe_loop())
+
+    async def _probe_loop(self) -> None:
+        while not self._primary_enabled:
+            await asyncio.sleep(self._probe_interval_seconds)
+            if self._primary_enabled:
+                break
+            try:
+                await self.primary.get_session("__ksadk_probe__")
+            except Exception:
+                continue
+            self._primary_enabled = True
+            logger.info(
+                "KSADK session persistence recovered; durable backend re-enabled",
+                extra={
+                    "session_backend_state": "recovered",
+                    "session_backend": type(self.primary).__name__,
+                },
+            )
+
+    async def _hydrate(self, session: Session) -> Session:
+        async with self._hydrate_lock:
+            self._primary_session_ids.add(session.id)
+            existing = await self.fallback.get_session(session.id)
+            if existing is None:
+                await self.fallback.create_session(
+                    session.agent_id,
+                    session.user_id,
+                    session_id=session.id,
+                )
+            existing_events = await self.fallback.get_events(session.id)
+            existing_ids = {event.id for event in existing_events}
+            for event in sorted(session.events, key=lambda item: item.seq_id):
+                if event.id not in existing_ids:
+                    await self.fallback.append_event(session.id, event)
+            await self.fallback.update_session_metadata(
+                session.id,
+                title=session.title,
+                title_source=session.title_source,
+                summary=session.summary,
+                first_prompt=session.first_prompt,
+                last_prompt=session.last_prompt,
+            )
+            current = await self.fallback.get_session(session.id)
+            if current is not None and session.state != current.state:
+                await self.fallback.update_state(
+                    agent_id=session.agent_id,
+                    user_id=session.user_id,
+                    session_id=session.id,
+                    scope="session",
+                    state_delta=session.state,
+                )
+            hydrated = await self.fallback.get_session(session.id)
+            if hydrated is None:
+                raise RuntimeError(f"Failed to hydrate live session {session.id}")
+            return hydrated
+
+    async def create_session(
+        self,
+        agent_id: str,
+        user_id: str,
+        session_id: Optional[str] = None,
+    ) -> Session:
+        if session_id:
+            ok, durable = await self._call_primary("get_session", session_id)
+            if ok and durable is not None:
+                return await self._hydrate(durable)
+            existing = await self.fallback.get_session(session_id)
+            if existing is not None:
+                return existing
+
+        live = await self.fallback.create_session(agent_id, user_id, session_id=session_id)
+        ok, durable = await self._call_primary(
+            "create_session",
+            agent_id,
+            user_id,
+            session_id=live.id,
+        )
+        if ok and durable is not None:
+            self._primary_session_ids.add(durable.id)
+            return await self._hydrate(durable)
+        return live
+
+    async def get_session(self, session_id: str) -> Optional[Session]:
+        live = await self.fallback.get_session(session_id)
+        ok, durable = await self._call_primary("get_session", session_id)
+        if ok and durable is not None:
+            return await self._hydrate(durable)
+        return live
+
+    async def get_session_metadata(self, session_id: str) -> Optional[Session]:
+        ok, durable = await self._call_primary("get_session_metadata", session_id)
+        if ok and durable is not None:
+            return cast(Session, durable)
+        return await self.fallback.get_session_metadata(session_id)
+
+    async def list_sessions(
+        self,
+        agent_id: str,
+        user_id: Optional[str] = None,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> list[Session]:
+        ok, durable_sessions = await self._call_primary(
+            "list_sessions",
+            agent_id,
+            user_id,
+            offset,
+            limit,
+        )
+        if ok:
+            return cast(list[Session], durable_sessions or [])
+        return await self.fallback.list_sessions(agent_id, user_id, offset, limit)
+
+    async def count_sessions(self, agent_id: str, user_id: Optional[str] = None) -> int:
+        ok, total = await self._call_primary("count_sessions", agent_id, user_id)
+        if ok:
+            return int(total or 0)
+        return await self.fallback.count_sessions(agent_id, user_id)
+
+    async def delete_session(self, session_id: str) -> bool:
+        deleted = await self.fallback.delete_session(session_id)
+        ok, durable_deleted = await self._call_primary("delete_session", session_id)
+        if ok:
+            self._primary_session_ids.discard(session_id)
+        return deleted or bool(durable_deleted) if ok else deleted
+
+    async def update_session_metadata(
+        self,
+        session_id: str,
+        *,
+        title: Optional[str] = None,
+        title_source: Optional[str] = None,
+        summary: Optional[str] = None,
+        first_prompt: Optional[str] = None,
+        last_prompt: Optional[str] = None,
+    ) -> Session:
+        if await self.fallback.get_session(session_id) is None:
+            await self.get_session(session_id)
+        live = await self.fallback.update_session_metadata(
+            session_id,
+            title=title,
+            title_source=title_source,
+            summary=summary,
+            first_prompt=first_prompt,
+            last_prompt=last_prompt,
+        )
+        await self._ensure_primary_session(session_id)
+        await self._call_primary(
+            "update_session_metadata",
+            session_id,
+            title=title,
+            title_source=title_source,
+            summary=summary,
+            first_prompt=first_prompt,
+            last_prompt=last_prompt,
+        )
+        return live
+
+    async def _ensure_primary_session(self, session_id: str) -> None:
+        """Create the session in PG if it only exists in memory (degraded-era)."""
+        if not self._primary_enabled or session_id in self._primary_session_ids:
+            return
+        async with self._primary_session_lock:
+            if not self._primary_enabled or session_id in self._primary_session_ids:
+                return
+            ok, durable = await self._call_primary("get_session", session_id)
+            if not ok:
+                return
+            if durable is None:
+                live = await self.fallback.get_session(session_id)
+                if live is None:
+                    return
+                ok, durable = await self._call_primary(
+                    "create_session",
+                    live.agent_id,
+                    live.user_id,
+                    session_id=live.id,
+                )
+                if not ok or durable is None:
+                    return
+            self._primary_session_ids.add(session_id)
+
+    async def append_event(self, session_id: str, event: SessionEvent) -> SessionEvent:
+        if await self.fallback.get_session(session_id) is None:
+            await self.get_session(session_id)
+        live = await self.fallback.append_event(session_id, event)
+        await self._ensure_primary_session(session_id)
+        await self._call_primary("append_event", session_id, event)
+        return live
+
+    async def get_events(
+        self,
+        session_id: str,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None,
+        after_seq_id: Optional[int] = None,
+        before_seq_id: Optional[int] = None,
+    ) -> list[SessionEvent]:
+        await self.get_session(session_id)
+        return cast(
+            list[SessionEvent],
+            await self.fallback.get_events(
+                session_id,
+                offset,
+                limit,
+                after_seq_id,
+                before_seq_id,
+            ),
+        )
+
+    async def count_events(
+        self,
+        session_id: str,
+        after_seq_id: Optional[int] = None,
+        before_seq_id: Optional[int] = None,
+    ) -> int:
+        await self.get_session(session_id)
+        return cast(
+            int,
+            await self.fallback.count_events(session_id, after_seq_id, before_seq_id),
+        )
+
+    async def get_events_for_agent(
+        self,
+        agent_id: str,
+        user_id: Optional[str] = None,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> list[SessionEvent]:
+        ok, events = await self._call_primary(
+            "get_events_for_agent", agent_id, user_id, offset, limit
+        )
+        if ok:
+            return cast(list[SessionEvent], events)
+        return await self.fallback.get_events_for_agent(agent_id, user_id, offset, limit)
+
+    async def count_events_for_agent(
+        self,
+        agent_id: str,
+        user_id: Optional[str] = None,
+    ) -> int:
+        ok, total = await self._call_primary("count_events_for_agent", agent_id, user_id)
+        if ok:
+            return int(total or 0)
+        return await self.fallback.count_events_for_agent(agent_id, user_id)
+
+    async def get_state(
+        self,
+        agent_id: str,
+        user_id: Optional[str],
+        session_id: Optional[str],
+        scope: str = "session",
+    ) -> Optional[SessionState]:
+        if session_id:
+            await self.get_session(session_id)
+        live = await self.fallback.get_state(agent_id, user_id, session_id, scope)
+        if live is not None or not self._primary_enabled:
+            return live
+        ok, durable = await self._call_primary(
+            "get_state",
+            agent_id,
+            user_id,
+            session_id,
+            scope,
+        )
+        if ok and durable is not None:
+            return await self.fallback.update_state(
+                agent_id=agent_id,
+                user_id=user_id,
+                session_id=session_id,
+                scope=scope,
+                state_delta=durable.state,
+            )
+        return live
+
+    async def update_state(
+        self,
+        *,
+        agent_id: str,
+        user_id: Optional[str],
+        session_id: Optional[str],
+        scope: str,
+        state_delta: dict[str, Any],
+    ) -> SessionState:
+        if session_id and await self.fallback.get_session(session_id) is None:
+            await self.get_session(session_id)
+        live = await self.fallback.update_state(
+            agent_id=agent_id,
+            user_id=user_id,
+            session_id=session_id,
+            scope=scope,
+            state_delta=state_delta,
+        )
+        if session_id:
+            await self._ensure_primary_session(session_id)
+        await self._call_primary(
+            "update_state",
+            agent_id=agent_id,
+            user_id=user_id,
+            session_id=session_id,
+            scope=scope,
+            state_delta=state_delta,
+        )
+        return live
+
+    async def aclose(self) -> None:
+        if self._probe_task is not None and not self._probe_task.done():
+            self._probe_task.cancel()
+            try:
+                await self._probe_task
+            except asyncio.CancelledError:
+                pass
+        for service in (self.primary, self.fallback):
+            close = getattr(service, "aclose", None)
+            if close is not None:
+                await close()

ksadk/skills/models.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Iterable
 from dataclasses import dataclass
 from typing import Any
 
@@ -48,7 +49,9 @@ class SkillRef:
             name=str(payload.get("Name") or payload.get("name") or ""),
             description=str(payload.get("Description") or payload.get("description") or ""),
             status=str(payload.get("Status") or payload.get("status") or ""),
-            content_hash=ContentHash.parse(payload.get("ContentHash") or payload.get("content_hash")),
+            content_hash=ContentHash.parse(
+                payload.get("ContentHash") or payload.get("content_hash")
+            ),
             archive_uri=str(payload.get("ArchiveUri") or payload.get("archive_uri") or ""),
             aliases=_string_tuple(payload.get("Aliases") or payload.get("aliases")),
             tags=_string_tuple(payload.get("Tags") or payload.get("tags")),
@@ -65,7 +68,9 @@ class SkillRef:
         version_key = self.version_id or self.version
         if not version_key and self.content_hash:
             version_key = self.content_hash.value
-        return "__".join(part.replace("/", "_").replace(":", "_") for part in (identity, version_key) if part)
+        return "__".join(
+            part.replace("/", "_").replace(":", "_") for part in (identity, version_key) if part
+        )
 
     @property
     def is_active(self) -> bool:
@@ -90,14 +95,20 @@ class SkillListResponse:
         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 []
+        skills_payload = (
+            data.get("Skills") or data.get("skills") or data.get("Items") or data.get("items") or []
+        )
         return cls(
             code=int(payload.get("Code") or payload.get("code") or 0),
             message=str(payload.get("Message") or payload.get("message") or ""),
             request_id=str(payload.get("RequestId") or payload.get("request_id") or ""),
             space_id=str(data.get("SkillSpaceId") or data.get("skill_space_id") or space_id),
-            space_name=str(data.get("SkillSpaceName") or data.get("skill_space_name") or space_name),
-            skills=[SkillRef.from_payload(item) for item in skills_payload if isinstance(item, dict)],
+            space_name=str(
+                data.get("SkillSpaceName") or data.get("skill_space_name") or space_name
+            ),
+            skills=[
+                SkillRef.from_payload(item) for item in skills_payload if isinstance(item, dict)
+            ],
         )
 
     def active_skills(self) -> list[SkillRef]:
@@ -107,6 +118,7 @@ class SkillListResponse:
 def _string_tuple(raw: Any) -> tuple[str, ...]:
     if raw is None:
         return ()
+    values: Iterable[Any]
     if isinstance(raw, str):
         values = raw.split(",")
     elif isinstance(raw, (list, tuple, set)):

ksadk/skills/package_store.py

@@ -79,11 +79,14 @@ class PackageStore:
         if not ref.content_hash:
             return
         if ref.content_hash.algorithm != "sha256":
-            raise SkillPackageError(f"Unsupported ContentHash algorithm: {ref.content_hash.algorithm}")
+            raise SkillPackageError(
+                f"Unsupported ContentHash algorithm: {ref.content_hash.algorithm}"
+            )
         actual = hashlib.sha256(content).hexdigest()
         if actual.lower() != ref.content_hash.value.lower():
             raise SkillPackageError(
-                f"ContentHash mismatch for {ref.name}: expected {ref.content_hash.render()}, got sha256:{actual}"
+                f"ContentHash mismatch for {ref.name}: expected "
+                f"{ref.content_hash.render()}, got sha256:{actual}"
             )
 
     def _safe_extract(self, archive_path: Path, extract_dir: Path) -> None:

ksadk/skills/runtime/agent.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import json
 import os
-import subprocess
 import sys
 from dataclasses import asdict
 from pathlib import Path
@@ -12,15 +11,29 @@ import httpx
 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.base import normalize_skill_names
 from ksadk.skills.runtime.executor import (
     WorkflowExecution,
     execute_workflow,
+)
+from ksadk.skills.runtime.executor import (
     _can_run_web_artifacts_builder as _executor_can_run_web_artifacts_builder,
+)
+from ksadk.skills.runtime.executor import (
     _run_command as _executor_run_command,
+)
+from ksadk.skills.runtime.executor import (
     _run_web_artifacts_builder as _executor_run_web_artifacts_builder,
+)
+from ksadk.skills.runtime.executor import (
     _runtime_timeout as _executor_runtime_timeout,
+)
+from ksadk.skills.runtime.executor import (
     _safe_project_name as _executor_safe_project_name,
+)
+from ksadk.skills.runtime.executor import (
     _tail as _executor_tail,
 )
 from ksadk.skills.runtime.request import (
@@ -28,8 +41,6 @@ from ksadk.skills.runtime.request import (
     SkillWorkflowRequestError,
     parse_workflow_request,
 )
-from ksadk.skills.runtime import loader as runtime_loader
-from ksadk.skills.runtime import registry as runtime_registry
 
 
 def _skill_space_ids() -> list[str]:
@@ -109,7 +120,9 @@ def run_agent(
         print("workflow=")
         print(f"skill_spaces={','.join(_skill_space_ids())}")
         print("loaded_skills=")
-        print(f"workflow_result={json.dumps(asdict(execution), ensure_ascii=False, sort_keys=True)}")
+        print(
+            f"workflow_result={json.dumps(asdict(execution), ensure_ascii=False, sort_keys=True)}"
+        )
         return 1
 
     prompt = request.workflow_prompt
@@ -125,7 +138,9 @@ def run_agent(
     print(f"loaded_skills={','.join(skill.name for skill in loaded_skills)}")
     print(f"selected_skills={json.dumps(selected_skill_names, ensure_ascii=False, sort_keys=True)}")
     if _SKILL_LOAD_WARNINGS:
-        print(f"skill_warnings={json.dumps(_SKILL_LOAD_WARNINGS, ensure_ascii=False, sort_keys=True)}")
+        print(
+            f"skill_warnings={json.dumps(_SKILL_LOAD_WARNINGS, ensure_ascii=False, sort_keys=True)}"
+        )
     print(f"workflow_result={json.dumps(asdict(execution), ensure_ascii=False, sort_keys=True)}")
     return 0 if execution.status != "failed" else 1
 

ksadk/skills/runtime/artifacts.py

@@ -20,11 +20,7 @@ def parse_artifact_lines(stdout: str) -> list[str]:
 def collect_output_dir_artifacts(output_dir: Path) -> list[str]:
     if not output_dir.is_dir():
         return []
-    return [
-        str(path)
-        for path in sorted(output_dir.rglob("*"))
-        if path.is_file()
-    ]
+    return [str(path) for path in sorted(output_dir.rglob("*")) if path.is_file()]
 
 
 def merge_artifacts(*groups: list[str]) -> list[str]:

ksadk/skills/runtime/backends/e2b.py

@@ -7,9 +7,11 @@ from typing import Any
 
 from ksadk.sandbox import (
     E2BSandboxBackend,
-    SandboxInputFile as RuntimeSandboxInputFile,
     SandboxSpec,
 )
+from ksadk.sandbox import (
+    SandboxInputFile as RuntimeSandboxInputFile,
+)
 from ksadk.skills.runtime.base import (
     SandboxInputFile,
     SkillRuntimeError,
@@ -75,10 +77,10 @@ class E2BSkillRuntimeBackend:
     @classmethod
     def from_env(cls) -> "E2BSkillRuntimeBackend":
         try:
-            from e2b import Sandbox
+            from e2b import Sandbox  # type: ignore[import-untyped]
         except ImportError as exc:
             raise SkillRuntimeError(
-                "e2b>=2.0.0 is required for KSADK_SKILL_RUNTIME_BACKEND=e2b"
+                "e2b>=2.15.3,<2.25.0 is required for KSADK_SKILL_RUNTIME_BACKEND=e2b"
             ) from exc
         return cls(
             sandbox_cls=Sandbox,
@@ -87,7 +89,11 @@ class E2BSkillRuntimeBackend:
                 or os.environ.get("KSADK_SKILL_RUNTIME_TEMPLATE_ID")
                 or ""
             ),
-            timeout=int(os.environ.get("KSADK_SANDBOX_TIMEOUT") or os.environ.get("KSADK_SKILL_RUNTIME_TIMEOUT") or "900"),
+            timeout=int(
+                os.environ.get("KSADK_SANDBOX_TIMEOUT")
+                or os.environ.get("KSADK_SKILL_RUNTIME_TIMEOUT")
+                or "900"
+            ),
             allow_internet_access=_bool_env(
                 "KSADK_SANDBOX_ALLOW_INTERNET_ACCESS",
                 _bool_env("KSADK_SKILL_RUNTIME_ALLOW_INTERNET_ACCESS", True),

ksadk/skills/runtime/backends/local.py

@@ -17,6 +17,12 @@ from ksadk.skills.runtime.base import (
 )
 
 
+def _coerce_output(value: str | bytes | None) -> str:
+    if isinstance(value, bytes):
+        return value.decode("utf-8", errors="replace")
+    return value or ""
+
+
 class LocalProcessSkillRuntimeBackend:
     def __init__(self, agent_path: str | Path, timeout: int = 900):
         self.agent_path = Path(agent_path)
@@ -67,7 +73,13 @@ class LocalProcessSkillRuntimeBackend:
                     encoding="utf-8",
                 )
                 completed = subprocess.run(
-                    [sys.executable, "-u", str(self.agent_path), "--request-file", str(request_path)],
+                    [
+                        sys.executable,
+                        "-u",
+                        str(self.agent_path),
+                        "--request-file",
+                        str(request_path),
+                    ],
                     text=True,
                     capture_output=True,
                     timeout=timeout or self.timeout,
@@ -86,8 +98,8 @@ class LocalProcessSkillRuntimeBackend:
             return SkillRuntimeResult(
                 runtime_id=f"local:{session_id}",
                 exit_code=None,
-                stdout=exc.stdout or "",
-                stderr=exc.stderr or "",
+                stdout=_coerce_output(exc.stdout),
+                stderr=_coerce_output(exc.stderr),
                 duration_ms=int((time.monotonic() - started) * 1000),
                 timed_out=True,
                 error_type="TimeoutExpired",

ksadk/skills/runtime/base.py

@@ -57,8 +57,7 @@ class SkillRuntimeBackend(Protocol):
         env: dict[str, str] | None = None,
         input_files: list[SandboxInputFile] | None = None,
         timeout: int = 900,
-    ) -> SkillRuntimeResult:
-        ...
+    ) -> SkillRuntimeResult: ...
 
 
 def parse_output_files(stdout: str) -> list[str]:

ksadk/skills/runtime/executor.py

@@ -82,7 +82,10 @@ def _can_run_web_artifacts_builder(skill: LocalSkill, prompt: str) -> bool:
     if not init_script.exists() or not bundle_script.exists():
         return False
     normalized = prompt.lower()
-    return any(marker in normalized for marker in ("web-artifacts-builder", "artifact", "bundle", "html", "react"))
+    return any(
+        marker in normalized
+        for marker in ("web-artifacts-builder", "artifact", "bundle", "html", "react")
+    )
 
 
 def _can_run_generic_workflow(skill: LocalSkill) -> bool:
@@ -91,7 +94,9 @@ def _can_run_generic_workflow(skill: LocalSkill) -> bool:
 
 def _run_web_artifacts_builder(skill: LocalSkill) -> WorkflowExecution:
     workdir = _skill_workdir()
-    project_name = _safe_project_name(os.environ.get("KSADK_SKILL_ARTIFACT_PROJECT") or "ksadk-artifact")
+    project_name = _safe_project_name(
+        os.environ.get("KSADK_SKILL_ARTIFACT_PROJECT") or "ksadk-artifact"
+    )
     project_dir = workdir / project_name
     workdir.mkdir(parents=True, exist_ok=True)
     if project_dir.exists():
@@ -114,7 +119,9 @@ def _run_web_artifacts_builder(skill: LocalSkill) -> WorkflowExecution:
         timeout=timeout,
     )
     commands.append(bundle_result)
-    output_files = [str(project_dir / "bundle.html")] if (project_dir / "bundle.html").exists() else []
+    output_files = (
+        [str(project_dir / "bundle.html")] if (project_dir / "bundle.html").exists() else []
+    )
     status = "ok" if bundle_result["exit_code"] == 0 and output_files else "failed"
     return WorkflowExecution(
         status=status,