openhands-sdk 1.8.1__py3-none-any.whl → 1.8.2__py3-none-any.whl

openhands/sdk/agent/base.py

@@ -384,6 +384,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/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/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/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/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/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

openhands/sdk/conversation/state.py

@@ -23,6 +23,7 @@ from openhands.sdk.security.confirmation_policy import (
     ConfirmationPolicyBase,
     NeverConfirm,
 )
+from openhands.sdk.utils.cipher import Cipher
 from openhands.sdk.utils.models import OpenHandsModel
 from openhands.sdk.workspace.base import BaseWorkspace
 
@@ -124,6 +125,7 @@ class ConversationState(OpenHandsModel):
     # ===== Private attrs (NOT Fields) =====
     _fs: FileStore = PrivateAttr()  # filestore for persistence
     _events: EventLog = PrivateAttr()  # now the storage for events
+    _cipher: Cipher | None = PrivateAttr(default=None)  # cipher for secret encryption
     _autosave_enabled: bool = PrivateAttr(
         default=False
     )  # to avoid recursion during init
@@ -166,8 +168,20 @@ class ConversationState(OpenHandsModel):
     def _save_base_state(self, fs: FileStore) -> None:
         """
         Persist base state snapshot (no events; events are file-backed).
+
+        If a cipher is configured, secrets will be encrypted. Otherwise, they
+        will be redacted (serialized as '**********').
         """
-        payload = self.model_dump_json(exclude_none=True)
+        context = {"cipher": self._cipher} if self._cipher else None
+        # Warn if secrets exist but no cipher is configured
+        if not self._cipher and self.secret_registry.secret_sources:
+            logger.warning(
+                f"Saving conversation state without cipher - "
+                f"{len(self.secret_registry.secret_sources)} secret(s) will be "
+                "redacted and lost on restore. Consider providing a cipher to "
+                "preserve secrets."
+            )
+        payload = self.model_dump_json(exclude_none=True, context=context)
         fs.write(BASE_STATE, payload)
 
     # ===== Factory: open-or-create (no load/save methods needed) =====
@@ -180,6 +194,7 @@ class ConversationState(OpenHandsModel):
         persistence_dir: str | None = None,
         max_iterations: int = 500,
         stuck_detection: bool = True,
+        cipher: Cipher | None = None,
     ) -> "ConversationState":
         """Create a new conversation state or resume from persistence.
 
@@ -203,6 +218,10 @@ class ConversationState(OpenHandsModel):
             persistence_dir: Directory for persisting state and events
             max_iterations: Maximum iterations per run
             stuck_detection: Whether to enable stuck detection
+            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.
 
         Returns:
             ConversationState ready for use
@@ -224,7 +243,9 @@ class ConversationState(OpenHandsModel):
 
         # ---- Resume path ----
         if base_text:
-            state = cls.model_validate(json.loads(base_text))
+            # Use cipher context for decrypting secrets if provided
+            context = {"cipher": cipher} if cipher else None
+            state = cls.model_validate(json.loads(base_text), context=context)
 
             # Restore the conversation with the same id
             if state.id != id:
@@ -236,6 +257,7 @@ class ConversationState(OpenHandsModel):
             # Attach event log early so we can read history for tool verification
             state._fs = file_store
             state._events = EventLog(file_store, dir_path=EVENTS_DIR)
+            state._cipher = cipher
 
             # Verify compatibility (agent class + tools)
             agent.verify(state.agent, events=state._events)
@@ -272,6 +294,7 @@ class ConversationState(OpenHandsModel):
         )
         state._fs = file_store
         state._events = EventLog(file_store, dir_path=EVENTS_DIR)
+        state._cipher = cipher
         state.stats = ConversationStats()
 
         state._save_base_state(file_store)  # initial snapshot

openhands/sdk/event/conversation_error.py

@@ -1,4 +1,5 @@
 from pydantic import Field
+from rich.text import Text
 
 from openhands.sdk.event.base import Event
 
@@ -23,3 +24,14 @@ class ConversationErrorEvent(Event):
 
     code: str = Field(description="Code for the error - typically a type")
     detail: str = Field(description="Details about the error")
+
+    @property
+    def visualize(self) -> Text:
+        """Return Rich Text representation of this conversation error event."""
+        content = Text()
+        content.append("Conversation Error\n", style="bold")
+        content.append("Code: ", style="bold")
+        content.append(self.code)
+        content.append("\n\nDetail:\n", style="bold")
+        content.append(self.detail)
+        return content

openhands/sdk/io/base.py

@@ -1,4 +1,6 @@
 from abc import ABC, abstractmethod
+from collections.abc import Iterator
+from contextlib import contextmanager
 
 
 class FileStore(ABC):
@@ -6,6 +8,9 @@ class FileStore(ABC):
 
     This class defines the interface for file storage backends that can
     handle basic file operations like reading, writing, listing, and deleting files.
+
+    Implementations should provide a locking mechanism via the `lock()` context
+    manager for thread/process-safe operations.
     """
 
     @abstractmethod
@@ -46,3 +51,50 @@ class FileStore(ABC):
         Args:
             path: The file or directory path to delete.
         """
+
+    @abstractmethod
+    def exists(self, path: str) -> bool:
+        """Check if a file or directory exists at the specified path.
+
+        Args:
+            path: The file or directory path to check.
+
+        Returns:
+            True if the path exists, False otherwise.
+        """
+
+    @abstractmethod
+    def get_absolute_path(self, path: str) -> str:
+        """Get the absolute filesystem path for a given relative path.
+
+        Args:
+            path: The relative path within the file store.
+
+        Returns:
+            The absolute path on the filesystem.
+        """
+
+    @abstractmethod
+    @contextmanager
+    def lock(self, path: str, timeout: float = 30.0) -> Iterator[None]:
+        """Acquire an exclusive lock for the given path.
+
+        This context manager provides thread and process-safe locking.
+        Implementations may use file-based locking, threading locks, or
+        other mechanisms as appropriate.
+
+        Args:
+            path: The path to lock (used to identify the lock).
+            timeout: Maximum seconds to wait for lock acquisition.
+
+        Yields:
+            None when lock is acquired.
+
+        Raises:
+            TimeoutError: If lock cannot be acquired within timeout.
+
+        Note:
+            File-based locking (flock) does NOT work reliably on NFS mounts
+            or network filesystems.
+        """
+        yield  # pragma: no cover

openhands/sdk/io/local.py

@@ -1,5 +1,9 @@
 import os
 import shutil
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+from filelock import FileLock, Timeout
 
 from openhands.sdk.io.cache import MemoryLRUCache
 from openhands.sdk.logger import get_logger
@@ -117,3 +121,24 @@ class LocalFileStore(FileStore):
 
         except Exception as e:
             logger.error(f"Error clearing local file store: {str(e)}")
+
+    def exists(self, path: str) -> bool:
+        """Check if a file or directory exists."""
+        return os.path.exists(self.get_full_path(path))
+
+    def get_absolute_path(self, path: str) -> str:
+        """Get absolute filesystem path."""
+        return self.get_full_path(path)
+
+    @contextmanager
+    def lock(self, path: str, timeout: float = 30.0) -> Iterator[None]:
+        """Acquire file-based lock using flock."""
+        lock_path = self.get_full_path(path)
+        os.makedirs(os.path.dirname(lock_path), exist_ok=True)
+        file_lock = FileLock(lock_path)
+        try:
+            with file_lock.acquire(timeout=timeout):
+                yield
+        except Timeout:
+            logger.error(f"Failed to acquire lock within {timeout}s: {lock_path}")
+            raise TimeoutError(f"Lock acquisition timed out: {path}")

openhands/sdk/io/memory.py

@@ -1,4 +1,8 @@
 import os
+import threading
+import uuid
+from collections.abc import Iterator
+from contextlib import contextmanager
 
 from openhands.sdk.io.base import FileStore
 from openhands.sdk.logger import get_logger
@@ -9,9 +13,13 @@ logger = get_logger(__name__)
 
 class InMemoryFileStore(FileStore):
     files: dict[str, str]
+    _instance_id: str
+    _lock: threading.Lock
 
     def __init__(self, files: dict[str, str] | None = None) -> None:
         self.files = {}
+        self._instance_id = uuid.uuid4().hex
+        self._lock = threading.Lock()
         if files is not None:
             self.files = files
 
@@ -51,4 +59,29 @@ class InMemoryFileStore(FileStore):
                 del self.files[key]
             logger.debug(f"Cleared in-memory file store: {path}")
         except Exception as e:
-            logger.error(f"Error clearing in-memory file store: {str(e)}")
+            logger.error(f"Error clearing in-memory file store: {e}")
+
+    def exists(self, path: str) -> bool:
+        """Check if a file exists."""
+        if path in self.files:
+            return True
+        return any(f.startswith(path + "/") for f in self.files)
+
+    def get_absolute_path(self, path: str) -> str:
+        """Get absolute path (uses temp dir with unique instance ID)."""
+        import tempfile
+
+        return os.path.join(
+            tempfile.gettempdir(), f"openhands_inmemory_{self._instance_id}", path
+        )
+
+    @contextmanager
+    def lock(self, path: str, timeout: float = 30.0) -> Iterator[None]:
+        """Acquire thread lock for in-memory store."""
+        acquired = self._lock.acquire(timeout=timeout)
+        if not acquired:
+            raise TimeoutError(f"Lock acquisition timed out: {path}")
+        try:
+            yield
+        finally:
+            self._lock.release()

openhands/sdk/llm/llm.py

@@ -424,8 +424,11 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
     ) -> None:
         if self.retry_listener is not None:
             self.retry_listener(attempt_number, num_retries, _err)
-        if self._telemetry is not None and _err is not None:
-            self._telemetry.on_error(_err)
+        # NOTE: don't call Telemetry.on_error here.
+        # This function runs for each retried failure (before the next attempt),
+        # which would create noisy duplicate error logs.
+        # The completion()/responses() exception handlers call Telemetry.on_error
+        # after retries are exhausted (final failure), which is what we want to log.
 
     # =========================================================================
     # Serializers
@@ -697,6 +700,7 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
             telemetry_ctx.update(
                 {
                     "llm_path": "responses",
+                    "instructions": instructions,
                     "input": input_items[:],
                     "tools": tools,
                     "kwargs": {k: v for k, v in call_kwargs.items()},

openhands/sdk/llm/utils/telemetry.py

@@ -1,6 +1,7 @@
 import json
 import os
 import time
+import traceback
 import uuid
 import warnings
 from collections.abc import Callable
@@ -121,7 +122,46 @@ class Telemetry(BaseModel):
         return self.metrics.deep_copy()
 
     def on_error(self, _err: BaseException) -> None:
-        # Stub for error tracking / counters
+        # Best-effort logging for failed requests (so we can debug malformed
+        # request payloads, e.g. orphaned Responses reasoning items).
+        self._last_latency = time.time() - (self._req_start or time.time())
+
+        if not self.log_enabled:
+            return
+        if not self.log_dir and not self._log_completions_callback:
+            return
+
+        try:
+            filename = (
+                f"{self.model_name.replace('/', '__')}-"
+                f"{time.time():.3f}-"
+                f"{uuid.uuid4().hex[:4]}-error.json"
+            )
+
+            data = self._req_ctx.copy()
+            data["error"] = {
+                "type": type(_err).__name__,
+                "message": str(_err),
+                "repr": repr(_err),
+                "traceback": "".join(
+                    traceback.format_exception(type(_err), _err, _err.__traceback__)
+                ),
+            }
+            data["timestamp"] = time.time()
+            data["latency_sec"] = self._last_latency
+            data["cost"] = 0.0
+
+            log_data = json.dumps(data, default=_safe_json, ensure_ascii=False)
+
+            if self._log_completions_callback:
+                self._log_completions_callback(filename, log_data)
+            elif self.log_dir:
+                os.makedirs(self.log_dir, exist_ok=True)
+                fname = os.path.join(self.log_dir, filename)
+                with open(fname, "w", encoding="utf-8") as f:
+                    f.write(log_data)
+        except Exception as e:
+            warnings.warn(f"Telemetry error logging failed: {e}")
         return
 
     # ---------- Helpers ----------
@@ -335,7 +375,6 @@ class Telemetry(BaseModel):
                 os.makedirs(self.log_dir, exist_ok=True)
                 if not os.access(self.log_dir, os.W_OK):
                     raise PermissionError(f"log_dir is not writable: {self.log_dir}")
-
                 fname = os.path.join(self.log_dir, filename)
                 with open(fname, "w", encoding="utf-8") as f:
                     f.write(log_data)

openhands/sdk/secret/secrets.py

@@ -5,10 +5,14 @@ from abc import ABC, abstractmethod
 import httpx
 from pydantic import Field, SecretStr, field_serializer, field_validator
 
+from openhands.sdk.logger import get_logger
 from openhands.sdk.utils.models import DiscriminatedUnionMixin
 from openhands.sdk.utils.pydantic_secrets import serialize_secret, validate_secret
 
 
+logger = get_logger(__name__)
+
+
 class SecretSource(DiscriminatedUnionMixin, ABC):
     """Source for a named secret which may be obtained dynamically"""
 
@@ -25,9 +29,11 @@ class SecretSource(DiscriminatedUnionMixin, ABC):
 class StaticSecret(SecretSource):
     """A secret stored locally"""
 
-    value: SecretStr
+    value: SecretStr | None = None
 
-    def get_value(self):
+    def get_value(self) -> str | None:
+        if self.value is None:
+            return None
         return self.value.get_secret_value()
 
     @field_validator("value")
@@ -58,7 +64,12 @@ class LookupSecret(SecretSource):
         for key, value in headers.items():
             if _is_secret_header(key):
                 secret_value = validate_secret(SecretStr(value), info)
-                assert secret_value is not None
+                # Skip headers with redacted/empty secret values
+                if secret_value is None:
+                    logger.debug(
+                        f"Skipping redacted header '{key}' during deserialization"
+                    )
+                    continue
                 result[key] = secret_value.get_secret_value()
             else:
                 result[key] = value
@@ -70,7 +81,11 @@ class LookupSecret(SecretSource):
         for key, value in headers.items():
             if _is_secret_header(key):
                 secret_value = serialize_secret(SecretStr(value), info)
-                assert secret_value is not None
+                if secret_value is None:
+                    logger.debug(
+                        f"Skipping redacted header '{key}' during serialization"
+                    )
+                    continue
                 result[key] = secret_value
             else:
                 result[key] = value

{openhands_sdk-1.8.1.dist-info → openhands_sdk-1.8.2.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: openhands-sdk
-Version: 1.8.1
+Version: 1.8.2
 Summary: OpenHands SDK - Core functionality for building AI agents
 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.dist-info → openhands_sdk-1.8.2.dist-info}/RECORD

@@ -2,14 +2,14 @@ openhands/sdk/__init__.py,sha256=FNRcPyCbvwYGrbSCxox_UWIHK5JuyCLHCyPLPZRd5sA,258
 openhands/sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 openhands/sdk/agent/__init__.py,sha256=yOn1ZCgTTq2VJlTzKDSzmWVPli1siBzqV89vlEHCwOg,137
 openhands/sdk/agent/agent.py,sha256=X00fM2FSjlZF36Y5E_-JkYS-n_x5RoEupTj2Rp6Gj_k,26361
-openhands/sdk/agent/base.py,sha256=ctAB3MnbnDLLLg1xlWJw6AovK494wiQrFigT57Eo_Z0,18991
+openhands/sdk/agent/base.py,sha256=GDT1sJsU3wIya0pYhfibuwQI3eejTNJ6DCFVUZnvg3k,19350
 openhands/sdk/agent/utils.py,sha256=AY_7VBFaJ2iorfh0MiS-mXaK6f8ONDejNcbkde_xTGg,8274
 openhands/sdk/agent/prompts/in_context_learning_example.j2,sha256=MGB0dPUlh6pwLoR_dBK-M3e5dtETX6C6WNjPcPixZmU,5512
 openhands/sdk/agent/prompts/in_context_learning_example_suffix.j2,sha256=k3Zwnd7Iq7kL4lo307RDuu1mxWXn6pSLsEdvKEXN3BU,164
 openhands/sdk/agent/prompts/security_policy.j2,sha256=K56d2aaZ88DI-y2DsMSDaiZRTTnkkzuBLjbzXfKHGA8,993
 openhands/sdk/agent/prompts/security_risk_assessment.j2,sha256=7o1tk6MIQpVD7sAES-sBhw4ckYLGQydzYnjjNitP5iY,1196
 openhands/sdk/agent/prompts/self_documentation.j2,sha256=Q0nLryVYnGg8Qk056-3tW2WJ2rwBijC5iqJByEdGAT0,1063
-openhands/sdk/agent/prompts/system_prompt.j2,sha256=KTBEZuez91aqLPX926kEzpRKoVHfXj8XVVUcxZjODhw,9055
+openhands/sdk/agent/prompts/system_prompt.j2,sha256=3-LMccbsoPXeX21Nbxy3xrTkP2wYSExrFr7GSKbWsJk,9283
 openhands/sdk/agent/prompts/system_prompt_interactive.j2,sha256=AW3rGuqu82BqbS1XMXVO4Fp-Apa8DPYZV3_nQYkzVtM,1388
 openhands/sdk/agent/prompts/system_prompt_long_horizon.j2,sha256=_oOHRIer_FSuRrBOSOPpe5Ueo9KgSTba5SPoHHpghCI,2995
 openhands/sdk/agent/prompts/system_prompt_planning.j2,sha256=wh01KX7yzeUSn5PtG3Ij0keRM6vmQuZZM6I0Fod4DK4,2934
@@ -20,10 +20,10 @@ openhands/sdk/agent/prompts/model_specific/openai_gpt/gpt-5-codex.j2,sha256=5iJv
 openhands/sdk/agent/prompts/model_specific/openai_gpt/gpt-5.j2,sha256=iMnSKjg2nrFoRUCkNMlGLoMmNWv_9bzK7D82dkJZCbQ,466
 openhands/sdk/context/__init__.py,sha256=r2YtpZMVFIIaKYVh2yjicTXYPURGhIUUdbliaLYbnnA,609
 openhands/sdk/context/agent_context.py,sha256=TUQB-RBmkKvnwMLKvG9eOc5TVlRnDtBOSeoXRA28JoA,12425
-openhands/sdk/context/view.py,sha256=Qi0H8vsCv2RDBpKBEurlknU2F37WvkI5xofvHAfd_v4,20489
+openhands/sdk/context/view.py,sha256=PtGPJunWSylUY3eSa0K1Oyrij2JpYH-Nv5wywLZHcYg,20244
 openhands/sdk/context/condenser/__init__.py,sha256=peHKPk51AujZhXvR2H0j1vBUJsCc8D6-OMHZ4Vk-pxU,568
 openhands/sdk/context/condenser/base.py,sha256=4_heKNni0BW3Lib3WMVRpzm8G03opW6VcHH9M_mV-j0,5869
-openhands/sdk/context/condenser/llm_summarizing_condenser.py,sha256=LjILEVsg5XB49Z5tig2c4QyRRPK4KzPM0b8-MKuIOVE,10688
+openhands/sdk/context/condenser/llm_summarizing_condenser.py,sha256=x8Z0hDDyFcCUwypkavQyLYh3YHRCzcRwi2tpS0bttGI,10812
 openhands/sdk/context/condenser/no_op_condenser.py,sha256=T87bTtJw4dqlOIZZZ4R_JFPXeSymDqlbsZtH6ng7N1E,474
 openhands/sdk/context/condenser/pipeline_condenser.py,sha256=wkbEA6R8u8u3Wi1AQmx1AKF9hQ25dLSeKuvB56N1Ohc,2145
 openhands/sdk/context/condenser/utils.py,sha256=kI4oechGeozHRTFPcq6UVbGgLL-6msR3D2-4fPssFVU,5599
@@ -43,7 +43,7 @@ openhands/sdk/conversation/__init__.py,sha256=1-xh49S2KJhtAjkHDaDHU28UWhfQLl3CeF
 openhands/sdk/conversation/base.py,sha256=sVpfqtyTVi7_d8rzI_gemZGHusVrNy9S_yNJmTGMEq8,8964
 openhands/sdk/conversation/conversation.py,sha256=KN4mqYqrzc5LWksliDmRV-wNg1FdF0IVyaopOKeajas,6079
 openhands/sdk/conversation/conversation_stats.py,sha256=ZlQ99kgG5YVCrZ4rqJlq63JaiInxX8jqv-q5lS7RN68,3038
-openhands/sdk/conversation/event_store.py,sha256=he-bwP823s5zAIdua_0ZgkkHQCJoAqbtV2SN0hibX30,5207
+openhands/sdk/conversation/event_store.py,sha256=JZF6AibFezcIzEw4IQqKHG8T8s53SfD_LkZycsOH6xY,7992
 openhands/sdk/conversation/events_list_base.py,sha256=n_YvgbhBPOPDbw4Kp68J0EKFM39vg95ng09GMfTz29s,505
 openhands/sdk/conversation/exceptions.py,sha256=9XkDVj2Q1PbB9GAIPLQ03M-r0r94ZRY1PmKZpSTDCY8,1757
 openhands/sdk/conversation/fifo_lock.py,sha256=nY5RsobNvVXBbAzwjqIxyQwPUh0AzffbTZw4PewhTTI,4240
@@ -51,12 +51,12 @@ openhands/sdk/conversation/persistence_const.py,sha256=om3pOQa5sGK8t_NUYb3Tz-7sK
 openhands/sdk/conversation/response_utils.py,sha256=rPlC3cDSmoQte6NZ0kK6h6-9ho5cbF8jEw-DiyEhgIM,1548
 openhands/sdk/conversation/secret_registry.py,sha256=6fY1zRxb55rC4uIMFcR0lDssIyyjaPh9pCWGqDikrek,4446
 openhands/sdk/conversation/serialization_diff.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-openhands/sdk/conversation/state.py,sha256=1TsOYXfXSKQ4odsZH8yFJ_d_zGZKPseOGvDVUaf1MzQ,16235
+openhands/sdk/conversation/state.py,sha256=VF3PD2THqgci6mA-meMaNGpB1KuCEW_4AOtHEIQ0flQ,17557
 openhands/sdk/conversation/stuck_detector.py,sha256=4UNU7Bh9M2yrw3RavMzZeFGQ5RutqavkckW3exFPqQw,11673
 openhands/sdk/conversation/title_utils.py,sha256=j40-dP-Oes-mhU2xUC7fCC8cB0wkMdbbDJU7WLHiVIo,7063
 openhands/sdk/conversation/types.py,sha256=q_yc3VNc8r3cdmvPXzpj7HvdLeDqv-37hCgOWMU65a4,1507
 openhands/sdk/conversation/impl/__init__.py,sha256=DmDFyNR4RU8eiMocKf2j9eBQomipP-rrJgU1LoVWTDA,220
-openhands/sdk/conversation/impl/local_conversation.py,sha256=-3ZfsxWgmC0lSf78rbylHJZlGXUdLorAADq-PJhX4ds,29163
+openhands/sdk/conversation/impl/local_conversation.py,sha256=Egdr7YLdZNcjmKlijracQigaoSBoiR2roinIWV2Ubnc,29559
 openhands/sdk/conversation/impl/remote_conversation.py,sha256=G8Asgg99gBxmQa2wsp-S6u8nEqJOq9DYjpzVNAi6AEI,38011
 openhands/sdk/conversation/visualizer/__init__.py,sha256=0LXpKlt2eJcrqP1z6jQP_nLx23V8ErnQkKYSxvUp0_A,275
 openhands/sdk/conversation/visualizer/base.py,sha256=77DdRdHAPSESxRCYyRRSOK7ROBlljscxogkFFr4YgM0,2323
@@ -70,7 +70,7 @@ openhands/sdk/critic/impl/pass_critic.py,sha256=kikTVZmve0DCTkQnhRutdUSff0OLbqH0
 openhands/sdk/event/__init__.py,sha256=ir-jRVA0QjEbFuDzJOYRq2kXTgUHs8eJ7_skoCRNzr8,1141
 openhands/sdk/event/base.py,sha256=QpQtYfYiZqaKWA-2xa4GEmk2qkUHKD6x-OIAk7SMnDs,5568
 openhands/sdk/event/condenser.py,sha256=sne9CxhhNq9UvJMKuKcw8tXuMgutuGh85TbbZHwYhPQ,2481
-openhands/sdk/event/conversation_error.py,sha256=gZMyliJx1xbyoJFYH0-AEHqznyiA8LZ7olPSidaNfuc,957
+openhands/sdk/event/conversation_error.py,sha256=73HDgrPDXba2_IMk3sMgk85_glkaKlZzEOk0afhm47Q,1392
 openhands/sdk/event/conversation_state.py,sha256=V-ti5SLL5SL330sEOQgpy-U8tErVwZYG0iC3AqjTUwo,3650
 openhands/sdk/event/llm_completion_log.py,sha256=VCxJiZBsn1F6TRV6fwvsPs6W9DpjghfIFmJJlGKztXg,1232
 openhands/sdk/event/token.py,sha256=QlEbBrfZaHe9tp8-Ot4vTd0T-_Vj7lpUqKfVJcVHOeI,497
@@ -93,12 +93,12 @@ openhands/sdk/hooks/executor.py,sha256=K-nE92r_6dsNV_ISEhoqIyxGvYzD9wgwSyHFM456N
 openhands/sdk/hooks/manager.py,sha256=woce5tBGaygQvKL_p3K77Xq9K8QMwsbZYjEmDCGHoIY,5864
 openhands/sdk/hooks/types.py,sha256=ZQp2_HVvOWI9YQPZInFJ0QdhpKo4UxGmq4YLYz9zfOY,1066
 openhands/sdk/io/__init__.py,sha256=6pXTWP03Wn5S7b6fOT0g3PYn-qSoEGGdrrwBqALYGA4,165
-openhands/sdk/io/base.py,sha256=kAcX0chfCswakiieJlKiHWoJgL3zOtaQauRqMPNYfW8,1355
+openhands/sdk/io/base.py,sha256=m-tMq3Em4DOd17cP0T6-gc9c_7FE-HakcPLScGGycVE,2958
 openhands/sdk/io/cache.py,sha256=TZD9Px-WK303WGjm5nin9n3TCKGiAJ-PIqrM5MFeg5c,2908
-openhands/sdk/io/local.py,sha256=IhU4OLP3-S8UCCWTm_xqw7XDYgeYms77b6I_FhZq0iU,4232
-openhands/sdk/io/memory.py,sha256=XIsdXsSyF-PzoYVmvJuO7Vtz-k3D5jMOFoZ5gHw8tbA,1712
+openhands/sdk/io/local.py,sha256=5ZibVqYj7hV5gpgYr2SKq2aSsAL1m2JykhtmRyVKyf8,5189
+openhands/sdk/io/memory.py,sha256=_GQ8WqilLJgdxtRccfVS653VDy1bo6CyZJDHGUQXEm8,2793
 openhands/sdk/llm/__init__.py,sha256=k8UneyfoDUMe0lSP4GSlYzrL2Fe3MkDUKpSg2OIDi_I,1206
-openhands/sdk/llm/llm.py,sha256=TqnqMd-i2EEF74y_3oOuOEbei912QY66JRFjG8REJt4,44139
+openhands/sdk/llm/llm.py,sha256=5T89gYuqvrsEqlyr_5j060muvXgpvia9FVhP0uM6Duo,44442
 openhands/sdk/llm/llm_registry.py,sha256=DL9yqSbAM7OBkzdIChLuxG2qk_oElW2tC2xem6mq0F8,3530
 openhands/sdk/llm/llm_response.py,sha256=DaBVBkij4Sz-RsYhRb3UUcvJCTzCBcOYQ9IhFwN4ukI,1988
 openhands/sdk/llm/message.py,sha256=Tw7sIw5A-rZqIH8dPI0UnoXf0KuPB8tURcJMQyv9JZg,25507
@@ -122,7 +122,7 @@ openhands/sdk/llm/utils/model_features.py,sha256=vAsRbD0dTIVM7SZUjO3Vwyd2CfDYxcR
 openhands/sdk/llm/utils/model_info.py,sha256=1mFYA7OcEyUB6k1doao8_w1XT7UMM_DAm57HcTpKkLw,2628
 openhands/sdk/llm/utils/model_prompt_spec.py,sha256=onw9-y7x0aJS8IOjNzeqhdvcFNwK1l_s0XgurWlnj5o,2587
 openhands/sdk/llm/utils/retry_mixin.py,sha256=M-hXp8EwP1FjNN6tgHiv133BtUQgRr9Kz_ZWxeAJLGA,4765
-openhands/sdk/llm/utils/telemetry.py,sha256=_9QedIEgHy_y-iadaofzDYU1_nQBjvbMR-H-KO6C3ss,13982
+openhands/sdk/llm/utils/telemetry.py,sha256=E7fDPXFdy3u3IVPTOijUCDw8vtqtMPjyhhlIg-NwU-M,15533
 openhands/sdk/llm/utils/unverified_models.py,sha256=SmYrX_WxXOJBanTviztqy1xPjOcLY4i3qvwNBEga_Dk,4797
 openhands/sdk/llm/utils/verified_models.py,sha256=_ioY2NHay8MQmfeiWRkT_53pA7DFhldopfQotTwORbk,1462
 openhands/sdk/logger/__init__.py,sha256=vZvFDYfW01Y8Act3tveMs3XxTysJlt4HeT-n6X_ujYk,330
@@ -141,7 +141,7 @@ openhands/sdk/plugin/__init__.py,sha256=NCzotHxOH7FfNVcJFy0ttNHOXf3xesHbDQ5sBa1t
 openhands/sdk/plugin/plugin.py,sha256=WiY_3n69kDYDPwY2srurYWbOLYO5ZiPtwJ0yOHc45jU,9970
 openhands/sdk/plugin/types.py,sha256=kYrlSKNnxZJiIB2XaJ2j4iKnG9jTXT8DIz54IzU6qyE,8122
 openhands/sdk/secret/__init__.py,sha256=Y-M2WPfYLfVYZSFZGTf6MDOnjsL5SayETtA4t9X0gjw,348
-openhands/sdk/secret/secrets.py,sha256=1PkD9oXJJlPgsN4D3brv3_HjIc2IQGy5BbcqZKJ_8Ew,2737
+openhands/sdk/secret/secrets.py,sha256=RFhyTBxwGgeYoojD56DtI_4CL43R8emo8WzvUH-8Z4w,3281
 openhands/sdk/security/__init__.py,sha256=x2-a0fsImxSM2msHl7gV0fENWyZbpY7-HW_CBwNrPZY,89
 openhands/sdk/security/analyzer.py,sha256=V6Fowh83sfEr1SdwK3UW1PNQHahHxwHfla0KndTombk,3994
 openhands/sdk/security/confirmation_policy.py,sha256=bsrIOfo3QOXNyKrmUVzQz070F3xbJ7uZp9WTr4RMdl8,2145
@@ -178,7 +178,7 @@ openhands/sdk/workspace/remote/__init__.py,sha256=eKkj6NOESMUBGDVC6_L2Wfuc4K6G-m
 openhands/sdk/workspace/remote/async_remote_workspace.py,sha256=MfnYoXvx_tZ7MKDGJCofnkYAJxfBKqNtM2Qprx3QQRk,5608
 openhands/sdk/workspace/remote/base.py,sha256=t-qbouLxkAsPKvVblXWWHKixHsLFz4bw3l9LW_n9_6o,6152
 openhands/sdk/workspace/remote/remote_workspace_mixin.py,sha256=CzHfnLUIra5sgPkP9kcggb1vHGOPpYQzLsHvGO2rRt0,10963
-openhands_sdk-1.8.1.dist-info/METADATA,sha256=RPyL9m_vuHKOVTQoTqsT6bVZFGbTuEh4ka4J-fXA41Q,546
-openhands_sdk-1.8.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-openhands_sdk-1.8.1.dist-info/top_level.txt,sha256=jHgVu9I0Blam8BXFgedoGKfglPF8XvW1TsJFIjcgP4E,10
-openhands_sdk-1.8.1.dist-info/RECORD,,
+openhands_sdk-1.8.2.dist-info/METADATA,sha256=FMs6gTS3Ot5Y62nDPD0H77XKgFgvvD0mj2b97cXrSQk,578
+openhands_sdk-1.8.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+openhands_sdk-1.8.2.dist-info/top_level.txt,sha256=jHgVu9I0Blam8BXFgedoGKfglPF8XvW1TsJFIjcgP4E,10
+openhands_sdk-1.8.2.dist-info/RECORD,,