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

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

@@ -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 → openhands_sdk-1.8.2}/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-1.8.1 → openhands_sdk-1.8.2}/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.8.2}/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.8.2}/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.8.2}/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.8.2}/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-1.8.1 → openhands_sdk-1.8.2}/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-1.8.1 → openhands_sdk-1.8.2}/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-1.8.2/openhands/sdk/io/base.py

@@ -0,0 +1,100 @@
+from abc import ABC, abstractmethod
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+
+class FileStore(ABC):
+    """Abstract base class for file storage operations.
+
+    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
+    def write(self, path: str, contents: str | bytes) -> None:
+        """Write contents to a file at the specified path.
+
+        Args:
+            path: The file path where contents should be written.
+            contents: The data to write, either as string or bytes.
+        """
+
+    @abstractmethod
+    def read(self, path: str) -> str:
+        """Read and return the contents of a file as a string.
+
+        Args:
+            path: The file path to read from.
+
+        Returns:
+            The file contents as a string.
+        """
+
+    @abstractmethod
+    def list(self, path: str) -> list[str]:
+        """List all files and directories at the specified path.
+
+        Args:
+            path: The directory path to list contents from.
+
+        Returns:
+            A list of file and directory names in the specified path.
+        """
+
+    @abstractmethod
+    def delete(self, path: str) -> None:
+        """Delete the file or directory at the specified path.
+
+        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-1.8.1 → openhands_sdk-1.8.2}/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-1.8.1 → openhands_sdk-1.8.2}/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-1.8.1 → openhands_sdk-1.8.2}/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-1.8.1 → openhands_sdk-1.8.2}/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)