openhands-sdk 1.8.1__tar.gz → 1.9.0__tar.gz

{openhands_sdk-1.8.1 → openhands_sdk-1.9.0}/PKG-INFO

@@ -1,10 +1,15 @@
 Metadata-Version: 2.4
 Name: openhands-sdk
-Version: 1.8.1
+Version: 1.9.0
 Summary: OpenHands SDK - Core functionality for building AI agents
+Project-URL: Source, https://github.com/OpenHands/software-agent-sdk
+Project-URL: Homepage, https://github.com/OpenHands/software-agent-sdk
+Project-URL: Documentation, https://docs.openhands.dev/sdk
+Project-URL: Bug Tracker, https://github.com/OpenHands/software-agent-sdk/issues
 Requires-Python: >=3.12
 Requires-Dist: deprecation>=2.1.0
 Requires-Dist: fastmcp>=2.11.3
+Requires-Dist: filelock>=3.20.1
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: litellm>=1.80.10
 Requires-Dist: pydantic>=2.12.5

{openhands_sdk-1.8.1 → openhands_sdk-1.9.0}/openhands/sdk/agent/agent.py

@@ -17,6 +17,7 @@ from openhands.sdk.conversation import (
     LocalConversation,
 )
 from openhands.sdk.conversation.state import ConversationExecutionStatus
+from openhands.sdk.critic.base import CriticResult
 from openhands.sdk.event import (
     ActionEvent,
     AgentErrorEvent,
@@ -120,6 +121,48 @@ class Agent(AgentBase):
             )
             on_event(event)
 
+    def _should_evaluate_with_critic(self, action: Action | None) -> bool:
+        """Determine if critic should evaluate based on action type and mode."""
+        if self.critic is None:
+            return False
+
+        if self.critic.mode == "all_actions":
+            return True
+
+        # For "finish_and_message" mode, only evaluate FinishAction
+        # (MessageEvent will be handled separately in step())
+        if isinstance(action, FinishAction):
+            return True
+
+        return False
+
+    def _evaluate_with_critic(
+        self, conversation: LocalConversation, event: ActionEvent | MessageEvent
+    ) -> CriticResult | None:
+        """Run critic evaluation on the current event and history."""
+        if self.critic is None:
+            return None
+
+        try:
+            # Build event history including the current event
+            events = list(conversation.state.events) + [event]
+            llm_convertible_events = [
+                e for e in events if isinstance(e, LLMConvertibleEvent)
+            ]
+
+            # Evaluate without git_patch for now
+            critic_result = self.critic.evaluate(
+                events=llm_convertible_events, git_patch=None
+            )
+            logger.info(
+                f"✓ Critic evaluation: score={critic_result.score:.3f}, "
+                f"success={critic_result.success}"
+            )
+            return critic_result
+        except Exception as e:
+            logger.error(f"✗ Critic evaluation failed: {e}", exc_info=True)
+            return None
+
     def _execute_actions(
         self,
         conversation: LocalConversation,
@@ -237,6 +280,7 @@ class Agent(AgentBase):
             for i, tool_call in enumerate(message.tool_calls):
                 action_event = self._get_action_event(
                     tool_call,
+                    conversation=conversation,
                     llm_response_id=llm_response.id,
                     on_event=on_event,
                     security_analyzer=state.security_analyzer,
@@ -275,6 +319,14 @@ class Agent(AgentBase):
             llm_message=message,
             llm_response_id=llm_response.id,
         )
+        # Run critic evaluation if configured for finish_and_message mode
+        if self.critic is not None and self.critic.mode == "finish_and_message":
+            critic_result = self._evaluate_with_critic(conversation, msg_event)
+            if critic_result is not None:
+                # Create new event with critic result
+                msg_event = msg_event.model_copy(
+                    update={"critic_result": critic_result}
+                )
         on_event(msg_event)
 
         # Emit VLLM token ids if enabled
@@ -389,6 +441,7 @@ class Agent(AgentBase):
     def _get_action_event(
         self,
         tool_call: MessageToolCall,
+        conversation: LocalConversation,
         llm_response_id: str,
         on_event: ConversationCallbackType,
         security_analyzer: analyzer.SecurityAnalyzerBase | None = None,
@@ -477,6 +530,7 @@ class Agent(AgentBase):
             on_event(event)
             return
 
+        # Create initial action event
         action_event = ActionEvent(
             action=action,
             thought=thought or [],
@@ -490,6 +544,16 @@ class Agent(AgentBase):
             security_risk=security_risk,
             summary=summary,
         )
+
+        # Run critic evaluation if configured
+        if self._should_evaluate_with_critic(action):
+            critic_result = self._evaluate_with_critic(conversation, action_event)
+            if critic_result is not None:
+                # Create new event with critic result
+                action_event = action_event.model_copy(
+                    update={"critic_result": critic_result}
+                )
+
         on_event(action_event)
         return action_event
 

{openhands_sdk-1.8.1 → openhands_sdk-1.9.0}/openhands/sdk/agent/base.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import re
 import sys
@@ -16,6 +18,7 @@ from pydantic import (
 from openhands.sdk.context.agent_context import AgentContext
 from openhands.sdk.context.condenser import CondenserBase
 from openhands.sdk.context.prompts.prompt import render_template
+from openhands.sdk.critic.base import CriticBase
 from openhands.sdk.llm import LLM
 from openhands.sdk.llm.utils.model_prompt_spec import get_model_prompt_spec
 from openhands.sdk.logger import get_logger
@@ -37,7 +40,6 @@ if TYPE_CHECKING:
         ConversationTokenCallbackType,
     )
 
-
 logger = get_logger(__name__)
 
 
@@ -174,6 +176,16 @@ class AgentBase(DiscriminatedUnionMixin, ABC):
         ],
     )
 
+    critic: CriticBase | None = Field(
+        default=None,
+        description=(
+            "EXPERIMENTAL: Optional critic to evaluate agent actions and messages "
+            "in real-time. API and behavior may change without notice. "
+            "May impact performance, especially in 'all_actions' mode."
+        ),
+        examples=[{"kind": "AgentFinishedCritic"}],
+    )
+
     # Runtime materialized tools; private and non-serializable
     _tools: dict[str, ToolDefinition] = PrivateAttr(default_factory=dict)
     _initialized: bool = PrivateAttr(default=False)
@@ -226,8 +238,8 @@ class AgentBase(DiscriminatedUnionMixin, ABC):
 
     def init_state(
         self,
-        state: "ConversationState",
-        on_event: "ConversationCallbackType",  # noqa: ARG002
+        state: ConversationState,
+        on_event: ConversationCallbackType,  # noqa: ARG002
     ) -> None:
         """Initialize the empty conversation state to prepare the agent for user
         messages.
@@ -238,7 +250,7 @@ class AgentBase(DiscriminatedUnionMixin, ABC):
         """
         self._initialize(state)
 
-    def _initialize(self, state: "ConversationState"):
+    def _initialize(self, state: ConversationState):
         """Create an AgentBase instance from an AgentSpec."""
 
         if self._initialized:
@@ -310,9 +322,9 @@ class AgentBase(DiscriminatedUnionMixin, ABC):
     @abstractmethod
     def step(
         self,
-        conversation: "LocalConversation",
-        on_event: "ConversationCallbackType",
-        on_token: "ConversationTokenCallbackType | None" = None,
+        conversation: LocalConversation,
+        on_event: ConversationCallbackType,
+        on_token: ConversationTokenCallbackType | None = None,
     ) -> None:
         """Taking a step in the conversation.
 
@@ -332,9 +344,9 @@ class AgentBase(DiscriminatedUnionMixin, ABC):
 
     def verify(
         self,
-        persisted: "AgentBase",
-        events: "Sequence[Any] | None" = None,
-    ) -> "AgentBase":
+        persisted: AgentBase,
+        events: Sequence[Any] | None = None,
+    ) -> AgentBase:
         """Verify that we can resume this agent from persisted state.
 
         This PR's goal is to *not* reconcile configuration between persisted and
@@ -384,6 +396,13 @@ class AgentBase(DiscriminatedUnionMixin, ABC):
                 if isinstance(event, ActionEvent) and event.tool_name
             }
 
+            # Add builtin tool names from include_default_tools
+            # These are runtime names like 'finish', 'think'
+            for tool_class_name in self.include_default_tools:
+                tool_class = BUILT_IN_TOOL_CLASSES.get(tool_class_name)
+                if tool_class is not None:
+                    runtime_names.add(tool_class.name)
+
             # Only require tools that were actually used in history.
             missing_used_tools = used_tools - runtime_names
             if missing_used_tools:

{openhands_sdk-1.8.1 → openhands_sdk-1.9.0}/openhands/sdk/agent/prompts/system_prompt.j2

@@ -43,6 +43,7 @@ You are OpenHands agent, a helpful AI assistant that can interact with a compute
 * When committing changes, use `git status` to see all modified files, and stage all files necessary for the commit. Use `git commit -a` whenever possible.
 * Do NOT commit files that typically shouldn't go into version control (e.g., node_modules/, .env files, build directories, cache files, large binaries) unless explicitly instructed by the user.
 * If unsure about committing certain files, check for the presence of .gitignore files or ask the user for clarification.
+* When running git commands that may produce paged output (e.g., `git diff`, `git log`, `git show`), use `git --no-pager <command>` or set `GIT_PAGER=cat` to prevent the command from getting stuck waiting for interactive input.
 </VERSION_CONTROL>
 
 <PULL_REQUESTS>

{openhands_sdk-1.8.1 → openhands_sdk-1.9.0}/openhands/sdk/context/condenser/llm_summarizing_condenser.py

@@ -42,7 +42,11 @@ class LLMSummarizingCondenser(RollingCondenser):
     llm: LLM
     max_size: int = Field(default=240, gt=0)
     max_tokens: int | None = None
+
     keep_first: int = Field(default=2, ge=0)
+    """Minimum number of events to preserve at the start of the view. The first
+    `keep_first` events in the conversation will never be condensed or summarized.
+    """
 
     @model_validator(mode="after")
     def validate_keep_first_vs_max_size(self):
@@ -236,13 +240,11 @@ class LLMSummarizingCondenser(RollingCondenser):
         # Calculate naive forgetting end (without considering atomic boundaries)
         naive_end = len(view) - events_from_tail
 
-        # Find actual forgetting_start: smallest manipulation index > keep_first
-        forgetting_start = view.find_next_manipulation_index(
-            self.keep_first, strict=True
-        )
+        # Find actual forgetting_start: smallest manipulation index >= keep_first
+        forgetting_start = view.find_next_manipulation_index(self.keep_first)
 
         # Find actual forgetting_end: smallest manipulation index >= naive_end
-        forgetting_end = view.find_next_manipulation_index(naive_end, strict=False)
+        forgetting_end = view.find_next_manipulation_index(naive_end)
 
         # Extract events to forget using boundary-aware indices
         forgotten_events = view[forgetting_start:forgetting_end]

{openhands_sdk-1.8.1 → openhands_sdk-1.9.0}/openhands/sdk/context/skills/skill.py

@@ -1,7 +1,7 @@
 import io
 import re
 from pathlib import Path
-from typing import Annotated, ClassVar, Union
+from typing import Annotated, ClassVar, Literal, Union
 from xml.sax.saxutils import escape as xml_escape
 
 import frontmatter
@@ -37,6 +37,22 @@ logger = get_logger(__name__)
 THIRD_PARTY_SKILL_MAX_CHARS = 10_000
 
 
+class SkillInfo(BaseModel):
+    """Lightweight representation of a skill's essential information.
+
+    This class provides a standardized, serializable format for skill metadata
+    that can be used across different components of the system.
+    """
+
+    name: str
+    type: Literal["repo", "knowledge", "agentskills"]
+    content: str
+    triggers: list[str] = Field(default_factory=list)
+    source: str | None = None
+    description: str | None = None
+    is_agentskills_format: bool = False
+
+
 class SkillResources(BaseModel):
     """Resource directories for a skill (AgentSkills standard).
 
@@ -560,6 +576,48 @@ class Skill(BaseModel):
         logger.debug(f"This skill requires user input: {variables}")
         return len(variables) > 0
 
+    def get_skill_type(self) -> Literal["repo", "knowledge", "agentskills"]:
+        """Determine the type of this skill.
+
+        Returns:
+            "agentskills" for AgentSkills format, "repo" for always-active skills,
+            "knowledge" for trigger-based skills.
+        """
+        if self.is_agentskills_format:
+            return "agentskills"
+        elif self.trigger is None:
+            return "repo"
+        else:
+            return "knowledge"
+
+    def get_triggers(self) -> list[str]:
+        """Extract trigger keywords from this skill.
+
+        Returns:
+            List of trigger strings, or empty list if no triggers.
+        """
+        if isinstance(self.trigger, KeywordTrigger):
+            return self.trigger.keywords
+        elif isinstance(self.trigger, TaskTrigger):
+            return self.trigger.triggers
+        return []
+
+    def to_skill_info(self) -> SkillInfo:
+        """Convert this skill to a SkillInfo.
+
+        Returns:
+            SkillInfo containing the skill's essential information.
+        """
+        return SkillInfo(
+            name=self.name,
+            type=self.get_skill_type(),
+            content=self.content,
+            triggers=self.get_triggers(),
+            source=self.source,
+            description=self.description,
+            is_agentskills_format=self.is_agentskills_format,
+        )
+
 
 def load_skills_from_dir(
     skill_dir: str | Path,

{openhands_sdk-1.8.1 → openhands_sdk-1.9.0}/openhands/sdk/context/skills/utils.py

@@ -5,14 +5,13 @@ from __future__ import annotations
 import json
 import os
 import re
-import shutil
-import subprocess
 from pathlib import Path
 from typing import TYPE_CHECKING
 
 from fastmcp.mcp_config import MCPConfig
 
 from openhands.sdk.context.skills.exceptions import SkillValidationError
+from openhands.sdk.git.cached_repo import try_cached_clone_or_update
 from openhands.sdk.logger import get_logger
 
 
@@ -316,77 +315,19 @@ def update_skills_repository(
 ) -> Path | None:
     """Clone or update the local skills repository.
 
+    Uses the shared git caching infrastructure from openhands.sdk.git.cached_repo.
+    When updating, performs: fetch -> checkout ref -> reset --hard to origin/ref.
+
     Args:
         repo_url: URL of the skills repository.
-        branch: Branch name to use.
+        branch: Branch name to checkout and track.
         cache_dir: Directory where the repository should be cached.
 
     Returns:
         Path to the local repository if successful, None otherwise.
     """
     repo_path = cache_dir / "public-skills"
-
-    try:
-        if repo_path.exists() and (repo_path / ".git").exists():
-            logger.debug(f"Updating skills repository at {repo_path}")
-            try:
-                subprocess.run(
-                    ["git", "fetch", "origin"],
-                    cwd=repo_path,
-                    check=True,
-                    capture_output=True,
-                    timeout=30,
-                )
-                subprocess.run(
-                    ["git", "reset", "--hard", f"origin/{branch}"],
-                    cwd=repo_path,
-                    check=True,
-                    capture_output=True,
-                    timeout=10,
-                )
-                logger.debug("Skills repository updated successfully")
-            except subprocess.TimeoutExpired:
-                logger.warning("Git pull timed out, using existing cached repository")
-            except subprocess.CalledProcessError as e:
-                logger.warning(
-                    f"Failed to update repository: {e.stderr.decode()}, "
-                    f"using existing cached version"
-                )
-        else:
-            logger.info(f"Cloning public skills repository from {repo_url}")
-            if repo_path.exists():
-                shutil.rmtree(repo_path)
-
-            subprocess.run(
-                [
-                    "git",
-                    "clone",
-                    "--depth",
-                    "1",
-                    "--branch",
-                    branch,
-                    repo_url,
-                    str(repo_path),
-                ],
-                check=True,
-                capture_output=True,
-                timeout=60,
-            )
-            logger.debug(f"Skills repository cloned to {repo_path}")
-
-        return repo_path
-
-    except subprocess.TimeoutExpired:
-        logger.warning(f"Git operation timed out for {repo_url}")
-        return None
-    except subprocess.CalledProcessError as e:
-        logger.warning(
-            f"Failed to clone/update repository {repo_url}: {e.stderr.decode()}"
-        )
-        return None
-    except Exception as e:
-        logger.warning(f"Error managing skills repository: {str(e)}")
-        return None
+    return try_cached_clone_or_update(repo_url, repo_path, ref=branch, update=True)
 
 
 def discover_skill_resources(skill_dir: Path) -> SkillResources:

{openhands_sdk-1.8.1 → openhands_sdk-1.9.0}/openhands/sdk/context/view.py

@@ -416,27 +416,22 @@ class View(BaseModel):
         else:
             return True
 
-    def find_next_manipulation_index(self, threshold: int, strict: bool = False) -> int:
-        """Find the smallest manipulation index greater than (or equal to) a threshold.
+    def find_next_manipulation_index(self, threshold: int) -> int:
+        """Find the smallest manipulation index greater than or equal to a threshold.
 
         This is a helper method for condensation logic that needs to find safe
         boundaries for forgetting events. Uses the cached manipulation_indices property.
 
         Args:
             threshold: The threshold value to compare against
-            strict: If True, finds index > threshold. If False, finds index >= threshold
 
         Returns:
-            The smallest manipulation index that satisfies the condition, or the
-            threshold itself if no such index exists
+            The smallest manipulation index >= threshold, or the threshold itself
+            if no such index exists
         """
         for idx in self.manipulation_indices:
-            if strict:
-                if idx > threshold:
-                    return idx
-            else:
-                if idx >= threshold:
-                    return idx
+            if idx >= threshold:
+                return idx
         return threshold
 
     @staticmethod

{openhands_sdk-1.8.1 → openhands_sdk-1.9.0}/openhands/sdk/conversation/base.py

@@ -162,6 +162,11 @@ class BaseConversation(ABC):
         """Set the confirmation policy for the conversation."""
         ...
 
+    @abstractmethod
+    def set_security_analyzer(self, analyzer: SecurityAnalyzerBase | None) -> None:
+        """Set the security analyzer for the conversation."""
+        ...
+
     @property
     def confirmation_policy_active(self) -> bool:
         return not isinstance(self.state.confirmation_policy, NeverConfirm)

{openhands_sdk-1.8.1 → openhands_sdk-1.9.0}/openhands/sdk/conversation/event_store.py

@@ -16,17 +16,34 @@ from openhands.sdk.logger import get_logger
 
 logger = get_logger(__name__)
 
+LOCK_FILE_NAME = ".eventlog.lock"
+LOCK_TIMEOUT_SECONDS = 30
+
 
 class EventLog(EventsListBase):
+    """Persistent event log with locking for concurrent writes.
+
+    This class provides thread-safe and process-safe event storage using
+    the FileStore's locking mechanism. Events are persisted to disk and
+    can be accessed by index or event ID.
+
+    Note:
+        For LocalFileStore, file locking via flock() does NOT work reliably
+        on NFS mounts or network filesystems. Users deploying with shared
+        storage should use alternative coordination mechanisms.
+    """
+
     _fs: FileStore
     _dir: str
     _length: int
+    _lock_path: str
 
     def __init__(self, fs: FileStore, dir_path: str = EVENTS_DIR) -> None:
         self._fs = fs
         self._dir = dir_path
         self._id_to_idx: dict[EventID, int] = {}
         self._idx_to_id: dict[int, EventID] = {}
+        self._lock_path = f"{dir_path}/{LOCK_FILE_NAME}"
         self._length = self._scan_and_build_index()
 
     def get_index(self, event_id: EventID) -> int:
@@ -54,7 +71,6 @@ class EventLog(EventsListBase):
         if isinstance(idx, slice):
             start, stop, step = idx.indices(self._length)
             return [self._get_single_item(i) for i in range(start, stop, step)]
-        # idx is int-like (SupportsIndex)
         return self._get_single_item(idx)
 
     def _get_single_item(self, idx: SupportsIndex) -> Event:
@@ -75,26 +91,82 @@ class EventLog(EventsListBase):
                 continue
             evt = Event.model_validate_json(txt)
             evt_id = evt.id
-            # only backfill mapping if missing
             if i not in self._idx_to_id:
                 self._idx_to_id[i] = evt_id
                 self._id_to_idx.setdefault(evt_id, i)
             yield evt
 
     def append(self, event: Event) -> None:
+        """Append an event with locking for thread/process safety.
+
+        Raises:
+            TimeoutError: If the lock cannot be acquired within LOCK_TIMEOUT_SECONDS.
+            ValueError: If an event with the same ID already exists.
+        """
         evt_id = event.id
-        # Check for duplicate ID
-        if evt_id in self._id_to_idx:
-            existing_idx = self._id_to_idx[evt_id]
-            raise ValueError(
-                f"Event with ID '{evt_id}' already exists at index {existing_idx}"
+
+        try:
+            with self._fs.lock(self._lock_path, timeout=LOCK_TIMEOUT_SECONDS):
+                # Sync with disk in case another process wrote while we waited
+                disk_length = self._count_events_on_disk()
+                if disk_length > self._length:
+                    self._sync_from_disk(disk_length)
+
+                if evt_id in self._id_to_idx:
+                    existing_idx = self._id_to_idx[evt_id]
+                    raise ValueError(
+                        f"Event with ID '{evt_id}' already exists at index "
+                        f"{existing_idx}"
+                    )
+
+                target_path = self._path(self._length, event_id=evt_id)
+                self._fs.write(target_path, event.model_dump_json(exclude_none=True))
+                self._idx_to_id[self._length] = evt_id
+                self._id_to_idx[evt_id] = self._length
+                self._length += 1
+        except TimeoutError:
+            logger.error(
+                f"Failed to acquire EventLog lock within {LOCK_TIMEOUT_SECONDS}s "
+                f"for event {evt_id}"
             )
+            raise
 
-        path = self._path(self._length, event_id=evt_id)
-        self._fs.write(path, event.model_dump_json(exclude_none=True))
-        self._idx_to_id[self._length] = evt_id
-        self._id_to_idx[evt_id] = self._length
-        self._length += 1
+    def _count_events_on_disk(self) -> int:
+        """Count event files on disk."""
+        try:
+            paths = self._fs.list(self._dir)
+        except FileNotFoundError:
+            # Directory doesn't exist yet - expected for new event logs
+            return 0
+        except Exception as e:
+            logger.warning("Error listing event directory %s: %s", self._dir, e)
+            return 0
+        return sum(
+            1
+            for p in paths
+            if p.rsplit("/", 1)[-1].startswith("event-") and p.endswith(".json")
+        )
+
+    def _sync_from_disk(self, disk_length: int) -> None:
+        """Sync state for events written by other processes.
+
+        Preserves existing index mappings and only scans new events.
+        """
+        # Preserve existing mappings
+        existing_idx_to_id = dict(self._idx_to_id)
+
+        # Re-scan to pick up new events
+        scanned_length = self._scan_and_build_index()
+
+        # Restore any mappings that were lost (e.g., for non-UUID event IDs)
+        for idx, evt_id in existing_idx_to_id.items():
+            if idx not in self._idx_to_id:
+                self._idx_to_id[idx] = evt_id
+            if evt_id not in self._id_to_idx:
+                self._id_to_idx[evt_id] = idx
+
+        # Use the higher of scanned length or disk_length
+        self._length = max(scanned_length, disk_length)
 
     def __len__(self) -> int:
         return self._length

{openhands_sdk-1.8.1 → openhands_sdk-1.9.0}/openhands/sdk/conversation/impl/local_conversation.py

@@ -40,6 +40,7 @@ from openhands.sdk.security.analyzer import SecurityAnalyzerBase
 from openhands.sdk.security.confirmation_policy import (
     ConfirmationPolicyBase,
 )
+from openhands.sdk.utils.cipher import Cipher
 from openhands.sdk.workspace import LocalWorkspace
 
 
@@ -77,6 +78,7 @@ class LocalConversation(BaseConversation):
             type[ConversationVisualizerBase] | ConversationVisualizerBase | None
         ) = DefaultConversationVisualizer,
         secrets: Mapping[str, SecretValue] | None = None,
+        cipher: Cipher | None = None,
         **_: object,
     ):
         """Initialize the conversation.
@@ -105,6 +107,10 @@ class LocalConversation(BaseConversation):
                       a dict with keys: 'action_observation', 'action_error',
                       'monologue', 'alternating_pattern'. Values are integers
                       representing the number of repetitions before triggering.
+            cipher: Optional cipher for encrypting/decrypting secrets in persisted
+                   state. If provided, secrets are encrypted when saving and
+                   decrypted when loading. If not provided, secrets are redacted
+                   (lost) on serialization.
         """
         super().__init__()  # Initialize with span tracking
         # Mark cleanup as initiated as early as possible to avoid races or partially
@@ -134,6 +140,7 @@ class LocalConversation(BaseConversation):
             else None,
             max_iterations=max_iteration_per_run,
             stuck_detection=stuck_detection,
+            cipher=cipher,
         )
 
         # Default callback: persist every event to state