openhands-sdk 1.59.0__tar.gz → 1.60.0__tar.gz

{openhands_sdk-1.59.0 → openhands_sdk-1.60.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-sdk
-Version: 1.59.0
+Version: 1.60.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
@@ -14,9 +14,9 @@ Requires-Dist: fakeredis[lua]>=2.32.1
 Requires-Dist: fastmcp<4,>=3.2.0
 Requires-Dist: filelock>=3.20.1
 Requires-Dist: httpx[socks]>=0.28.1
-Requires-Dist: jsonschema>=4.23.0
+Requires-Dist: jsonschema>=4.26.0
 Requires-Dist: joserfc>=1.7.5
-Requires-Dist: litellm<1.106,>=1.93.0
+Requires-Dist: litellm<1.106,>=1.104.3
 Requires-Dist: pillow>=12.3.0
 Requires-Dist: pydantic>=2.13.5
 Requires-Dist: python-frontmatter>=1.3.0
@@ -31,4 +31,4 @@ Requires-Dist: boto3>=1.35.0; extra == "boto3"
 Provides-Extra: toolshield
 Requires-Dist: toolshield<0.2,>=0.1.3; extra == "toolshield"
 Provides-Extra: vertex
-Requires-Dist: google-cloud-aiplatform>=2.1.3; extra == "vertex"
+Requires-Dist: google-cloud-aiplatform>=2.5.0; extra == "vertex"

{openhands_sdk-1.59.0 → openhands_sdk-1.60.0}/openhands/sdk/__init__.py

@@ -26,6 +26,8 @@ from openhands.sdk.io import FileStore, LocalFileStore
 from openhands.sdk.llm import (
     LLM,
     LLM_PROFILE_SCHEMA_VERSION,
+    DecisionModel,
+    DecisionResult,
     FallbackStrategy,
     ImageContent,
     LLMProfileStore,
@@ -119,6 +121,8 @@ _print_banner(__version__)
 
 __all__ = [
     "LLM",
+    "DecisionModel",
+    "DecisionResult",
     "LLM_PROFILE_SCHEMA_VERSION",
     "LLMRegistry",
     "LLMProfileStore",

{openhands_sdk-1.59.0 → openhands_sdk-1.60.0}/openhands/sdk/agent/acp_agent.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 import asyncio
 import atexit
 import contextlib
+import functools
 import inspect
 import json
 import os
@@ -1342,6 +1343,14 @@ class _OpenHandsACPBridge:
         self.accumulated_text: list[str] = []
         self.accumulated_thoughts: list[str] = []
         self.accumulated_tool_calls: list[dict[str, Any]] = []
+        # Text and thoughts said before a tool call are emitted as their own
+        # message ahead of that call (``on_text_segment``), so the transcript
+        # keeps the agent's narration where it was said. These mark where the
+        # segment not yet emitted starts; the rest of the turn ends it.
+        self._segment_text_start = 0
+        self._segment_thought_start = 0
+        self.text_segments_emitted = 0
+        self.on_text_segment: Callable[[str, str], None] | None = None
         # Emits the LLM/TOOL spans an ACP turn would otherwise never produce.
         self.trace = ACPTurnTrace(acp_server=None, model_id=None)
         self.on_token: Any = None  # ConversationTokenCallbackType | None
@@ -1387,6 +1396,10 @@ class _OpenHandsACPBridge:
         self.accumulated_text.clear()
         self.accumulated_thoughts.clear()
         self.accumulated_tool_calls.clear()
+        self._segment_text_start = 0
+        self._segment_thought_start = 0
+        self.text_segments_emitted = 0
+        self.on_text_segment = None
         self.on_token = None
         self.on_event = None
         self.on_activity = None
@@ -1529,6 +1542,7 @@ class _OpenHandsACPBridge:
             if event is not None:
                 event.set()
         elif isinstance(update, ToolCallStart):
+            self._emit_text_segment()
             entry = {
                 "tool_call_id": update.tool_call_id,
                 "title": update.title,
@@ -1599,6 +1613,41 @@ class _OpenHandsACPBridge:
         else:
             logger.debug("ACP session update: %s", type(update).__name__)
 
+    def segment_text(self) -> str:
+        """Text said since the last emitted segment (the whole turn if none)."""
+        return "".join(self.accumulated_text[self._segment_text_start :])
+
+    def segment_thoughts(self) -> str:
+        """Thoughts since the last emitted segment (the whole turn if none)."""
+        return "".join(self.accumulated_thoughts[self._segment_thought_start :])
+
+    def _emit_text_segment(self) -> None:
+        """Hand the text and thoughts said so far to ``on_text_segment``.
+
+        Called when a tool call starts, so that narration such as "let me run
+        the tests" lands before the tool call it announces instead of joining
+        the turn's final message. The joined segment is masked again because a
+        secret split across chunks only reassembles here.
+        """
+        if self.on_text_segment is None:
+            return
+        text = self.segment_text()
+        thoughts = self.segment_thoughts()
+        if not text.strip() and not thoughts.strip():
+            return
+        try:
+            self.on_text_segment(self._mask_value(text), self._mask_value(thoughts))
+        except CredentialBindingError:
+            # Keep the segment: the turn's final text carries it, and the
+            # recorded masking error fails the turn before anything persists.
+            return
+        except Exception:
+            logger.debug("on_text_segment callback failed", exc_info=True)
+            return
+        self._segment_text_start = len(self.accumulated_text)
+        self._segment_thought_start = len(self.accumulated_thoughts)
+        self.text_segments_emitted += 1
+
     def _emit_tool_call_event(self, tc: dict[str, Any]) -> None:
         """Emit an ACPToolCallEvent reflecting the current state of ``tc``.
 
@@ -2805,16 +2854,19 @@ class ACPAgent(AgentBase):
                     if self._closed:
                         raise CredentialSyncError("Credential binding is closed.")
                 try:
-                    lifecycle.materialize(state.secret_registry, env)
-                    durable_path = (
-                        self._acp_file_secret_dir(state, spec.subdir) / spec.filename
-                    )
-                    try:
-                        durable_path.unlink(missing_ok=True)
-                    except OSError as exc:
-                        raise CredentialSyncError(
-                            "Durable credential copy could not be removed."
-                        ) from exc
+                    # The CLI keeps its state in the conversation's durable
+                    # directory; the lifecycle links the credential in from a
+                    # temporary file, so it never persists there.
+                    home = self._acp_file_secret_dir(state, spec.subdir)
+                    lifecycle.materialize(state.secret_registry, env, home=home)
+                    durable_path = home / spec.filename
+                    if lifecycle.path != durable_path:
+                        try:
+                            durable_path.unlink(missing_ok=True)
+                        except OSError as exc:
+                            raise CredentialSyncError(
+                                "Durable credential copy could not be removed."
+                            ) from exc
                 except BaseException:
                     env.pop("CODEX_HOME", None)
                     lifecycle.discard()
@@ -3469,11 +3521,41 @@ class ACPAgent(AgentBase):
         self._client.trace.start_turn(prompt)
         self._client.on_token = on_token
         self._client.on_event = on_event
+        self._client.on_text_segment = functools.partial(
+            self._emit_text_segment, on_event
+        )
         self._client.on_activity = self._on_activity
         # Start the idle-timeout clock fresh for this attempt so the deadline
         # is measured from the send (or retry), not from a stale value.
         self._client.arm_activity_clock()
 
+    def _emit_text_segment(
+        self, on_event: ConversationCallbackType, text: str, thoughts: str
+    ) -> None:
+        """Emit text the agent said before a tool call as its own message.
+
+        It retires the stream slot that carried this text and opens a new one,
+        so the rest of the turn streams below the tool call.
+        """
+        minted: dict[str, Any] = {}
+        if self._stream is not None and (item_id := self._stream.claim()):
+            minted["id"] = item_id
+        on_event(
+            MessageEvent(
+                **minted,
+                source="agent",
+                llm_message=Message(
+                    role="assistant",
+                    content=[TextContent(text=text)],
+                    reasoning_content=thoughts or None,
+                ),
+            )
+        )
+        if self._stream is not None:
+            if minted:
+                self._stream.commit()
+            self._stream.next_item()
+
     def _cancel_inflight_tool_calls(self) -> None:
         """Emit a terminal ``failed`` ACPToolCallEvent for every tool call
         in the accumulator that has not reached a terminal status yet.
@@ -3857,13 +3939,18 @@ class ACPAgent(AgentBase):
         # gets caught before landing in the persisted event stream.
         self._track_file_credentials_for_masking()
         mask = state.secret_registry.mask_secrets_in_output
-        response_text = mask("".join(self._client.accumulated_text))
-        thought_text = mask("".join(self._client.accumulated_thoughts))
-        if not response_text:
+        # Text said before a tool call was already emitted as its own message
+        # (``_emit_text_segment``); the finish carries what the agent said
+        # after its last tool call.
+        response_text = mask(self._client.segment_text())
+        thought_text = mask(self._client.segment_thoughts())
+        if not response_text and not self._client.text_segments_emitted:
             response_text = "(No response from ACP server)"
 
         self._client.trace.finish_turn(
-            response_text, thought_text, self._client.accumulated_tool_calls
+            mask("".join(self._client.accumulated_text)) or response_text,
+            mask("".join(self._client.accumulated_thoughts)),
+            self._client.accumulated_tool_calls,
         )
 
         # ACP step() boundaries are full remote assistant turns, not
@@ -4039,6 +4126,7 @@ class ACPAgent(AgentBase):
             return
         self._client.trace.abandon()
         self._client.on_event = None
+        self._client.on_text_segment = None
         self._client.on_token = None
         self._client.on_activity = None
 

{openhands_sdk-1.59.0 → openhands_sdk-1.60.0}/openhands/sdk/agent/acp_file_credentials.py

@@ -51,7 +51,12 @@ class ACPFileCredentialLifecycle(Protocol):
     secret_name: str
     path: Path | None
 
-    def materialize(self, registry: SecretRegistry, env: dict[str, str]) -> None: ...
+    def materialize(
+        self,
+        registry: SecretRegistry,
+        env: dict[str, str],
+        home: Path | None = None,
+    ) -> None: ...
 
     def track_current(self) -> None: ...
 
@@ -114,6 +119,7 @@ class _CodexAuthLifecycle:
         self.run_async = run_async
         self.path: Path | None = None
         self._runtime_dir: Path | None = None
+        self._home_link: Path | None = None
         self._registry: SecretRegistry | None = None
         self._expected_version: str | None = None
         self._local_digest: str | None = None
@@ -126,7 +132,20 @@ class _CodexAuthLifecycle:
         self._monitor: threading.Thread | None = None
         self._closed = False
 
-    def materialize(self, registry: SecretRegistry, env: dict[str, str]) -> None:
+    def materialize(
+        self,
+        registry: SecretRegistry,
+        env: dict[str, str],
+        home: Path | None = None,
+    ) -> None:
+        """Write the credential to a private temporary file for the CLI.
+
+        With ``home`` (the conversation's durable Codex directory), ``CODEX_HOME``
+        points there so the CLI's threads and state survive a restart, and
+        ``home/auth.json`` is a symlink to the temporary file. codex resolves that
+        link and replaces its target when it refreshes the login, so the
+        credential itself never lands in ``home``.
+        """
         resolved = self._load()
         if not is_valid_codex_auth(resolved.value):
             raise CredentialNeedsReauthentication(
@@ -135,8 +154,13 @@ class _CodexAuthLifecycle:
         runtime_dir = Path(tempfile.mkdtemp(prefix="openhands-codex-"))
         runtime_dir.chmod(0o700)
         path = runtime_dir / "auth.json"
+        codex_home = runtime_dir
         try:
             write_secret_file(path, resolved.value)
+            if home is not None:
+                link = self._link_into_home(home, path)
+                if link is not None:
+                    path, codex_home = link, home
         except BaseException:
             shutil.rmtree(runtime_dir, ignore_errors=True)
             raise
@@ -146,7 +170,7 @@ class _CodexAuthLifecycle:
         self._expected_version = resolved.version
         self._local_digest = self._digest(resolved.value)
         self._track(resolved.value)
-        env["CODEX_HOME"] = str(runtime_dir)
+        env["CODEX_HOME"] = str(codex_home)
         monitor = threading.Thread(
             target=self._monitor_loop,
             name="codex-credential-monitor",
@@ -164,6 +188,26 @@ class _CodexAuthLifecycle:
             extra={"credential": self.secret_name},
         )
 
+    def _link_into_home(self, home: Path, target: Path) -> Path | None:
+        link = home / "auth.json"
+        try:
+            home.mkdir(mode=0o700, parents=True, exist_ok=True)
+            # A real file here is a stale copy (older releases, or a CLI that
+            # replaced the link): the binding's value supersedes it.
+            link.unlink(missing_ok=True)
+            link.symlink_to(target)
+        except OSError:
+            # No symlinks (e.g. Windows without the privilege): keep the CLI's
+            # state in the temporary directory, as before.
+            logger.warning(
+                "credential_binding_home_link_failed",
+                extra={"credential": self.secret_name},
+                exc_info=True,
+            )
+            return None
+        self._home_link = link
+        return link
+
     def track_current(self) -> None:
         try:
             self._raise_sticky_error()
@@ -230,12 +274,22 @@ class _CodexAuthLifecycle:
         self._cleanup_runtime()
 
     def _cleanup_runtime(self) -> None:
+        home_link = self._home_link
+        if home_link is not None:
+            try:
+                home_link.unlink(missing_ok=True)
+            except OSError:
+                logger.warning(
+                    "credential_binding_home_link_cleanup_failed",
+                    extra={"credential": self.secret_name},
+                )
         runtime_dir = self._runtime_dir
         if runtime_dir is not None:
             shutil.rmtree(runtime_dir, ignore_errors=True)
         with self._lock:
             self.path = None
             self._runtime_dir = None
+            self._home_link = None
             self._registry = None
             self._monitor = None
             self._closed = True

{openhands_sdk-1.59.0 → openhands_sdk-1.60.0}/openhands/sdk/agent/agent.py

@@ -51,6 +51,7 @@ from openhands.sdk.event.condenser import (
     CondensationRequest,
 )
 from openhands.sdk.event.error_classification import AGENT_OUTCOME
+from openhands.sdk.event.llm_convertible.observation import ToolValidationError
 from openhands.sdk.event.security import SecurityAnalysisEvent
 from openhands.sdk.event.types import ROOT_PARENT_ID, EventID
 from openhands.sdk.llm import (
@@ -1322,6 +1323,7 @@ class Agent(CriticMixin, ResponseDispatchMixin, AgentBase):
         thinking_blocks: list[ThinkingBlock | RedactedThinkingBlock] | None = None,
         responses_reasoning_item: ReasoningItemModel | None = None,
         stream: StreamContext | None = None,
+        validation_errors: list[ToolValidationError] | None = None,
     ) -> None:
         try:
             json.loads(tool_call.arguments)
@@ -1361,6 +1363,7 @@ class Agent(CriticMixin, ResponseDispatchMixin, AgentBase):
             tool_name=tool_name,
             tool_call_id=tool_call.id,
             classification=AGENT_OUTCOME,
+            validation_errors=validation_errors,
         )
         record_tool_result(
             conversation,
@@ -1489,6 +1492,18 @@ class Agent(CriticMixin, ResponseDispatchMixin, AgentBase):
                 thinking_blocks=thinking_blocks,
                 responses_reasoning_item=responses_reasoning_item,
                 stream=stream,
+                validation_errors=(
+                    [
+                        ToolValidationError(type=detail["type"], loc=detail["loc"])
+                        for detail in e.errors(
+                            include_url=False,
+                            include_context=False,
+                            include_input=False,
+                        )
+                    ]
+                    if isinstance(e, ValidationError)
+                    else None
+                ),
             )
             return
 

{openhands_sdk-1.59.0 → openhands_sdk-1.60.0}/openhands/sdk/agent/base.py

@@ -28,6 +28,9 @@ from openhands.sdk.context.prompts.section import Platform, PromptContext
 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.llm.utils.openhands_provider import (
+    OPENHANDS_SYSTEM_IDENTITY,
+)
 from openhands.sdk.logger import get_logger
 from openhands.sdk.mcp.client import MCPClient
 from openhands.sdk.mcp.config import MCPServer
@@ -64,10 +67,7 @@ logger = get_logger(__name__)
 # replaces the default identity in the system prompt.
 
 _SOUL_PATH = get_user_persistence_dir() / "SOUL.md"
-_DEFAULT_SOUL = (
-    "You are OpenHands agent, a helpful AI assistant that can interact"
-    " with a computer to solve tasks."
-)
+_DEFAULT_SOUL = OPENHANDS_SYSTEM_IDENTITY
 
 # Built-in prompt dir. The registry only stands in for built-in prompts here; a
 # subclass with its own prompts/ keeps the Jinja render path.
@@ -162,12 +162,14 @@ class AgentBase(DiscriminatedUnionMixin, ABC):
         default_factory=lambda: [tool.__name__ for tool in BUILT_IN_TOOLS],
         description=(
             "List of default tool class names to include. By default, the agent "
-            "includes 'FinishTool' and 'ThinkTool'. Set to an empty list to disable "
-            "all default tools, or provide a subset to include only specific ones. "
-            "Example: include_default_tools=['FinishTool'] to only include FinishTool, "
-            "or include_default_tools=[] to disable all default tools."
+            "includes 'FinishTool'. Set to an empty list to disable all default "
+            "tools, or provide a subset to include specific ones. Add 'ThinkTool' "
+            "explicitly to enable the think tool. "
+            "Example: include_default_tools=['FinishTool', 'ThinkTool'] to enable "
+            "the think tool, or include_default_tools=[] to disable all default "
+            "tools."
         ),
-        examples=[["FinishTool", "ThinkTool"], ["FinishTool"], []],
+        examples=[["FinishTool"], ["FinishTool", "ThinkTool"], []],
     )
     agent_context: AgentContext | None = Field(
         default=None,

{openhands_sdk-1.59.0 → openhands_sdk-1.60.0}/openhands/sdk/agent/stream_context.py

@@ -82,9 +82,11 @@ class StreamContext:
         on_token: Callable[[Any], None] | None,
         on_stream: StreamProgressCallbackType | None,
         mask: Callable[[], StreamOutputMask],
+        last_seq: Callable[[], int | None] | None = None,
     ) -> None:
         self.item_id = item_id
         self._anchor_seq = anchor_seq
+        self._last_seq = last_seq
         self._on_token = on_token
         self._on_stream = on_stream
         self._mask = mask
@@ -99,6 +101,7 @@ class StreamContext:
         self._reserved = False
         self._claimed = False
         self._chunk_id: str | None = None
+        self._anchor_pending = False
 
     @classmethod
     def open(
@@ -108,13 +111,18 @@ class StreamContext:
     ) -> StreamContext:
         """Mint an id and read the anchor. Neither touches the event log."""
         state = conversation.state
-        length = len(state.events)
+
+        def last_seq() -> int | None:
+            length = len(state.events)
+            return length - 1 if length else None
+
         return cls(
             item_id=str(uuid.uuid4()),
-            anchor_seq=length - 1 if length else None,
+            anchor_seq=last_seq(),
             on_token=on_token,
             on_stream=conversation.on_stream,
             mask=state.secret_registry.compile_stream_mask,
+            last_seq=last_seq,
         )
 
     @property
@@ -176,6 +184,28 @@ class StreamContext:
         if self._reserved:
             self._claimed = True
 
+    def next_item(self) -> None:
+        """Open a fresh slot for the rest of the step, after a committed item.
+
+        For a step that emits several durable items in turn (an ACP turn's text
+        segments between its tool calls). The new slot anchors on the event log
+        as it stands when its first token arrives, so it streams below every
+        event emitted in between.
+        """
+        self.close("no_durable_event")
+        self.item_id = str(uuid.uuid4())
+        self._anchor_seq = None
+        self._masks.clear()
+        self._attempt = 1
+        self._order = itertools.count()
+        self._started = False
+        self._opened = False
+        self._started_attempt = None
+        self._reserved = False
+        self._claimed = False
+        self._chunk_id = None
+        self._anchor_pending = self._last_seq is not None
+
     def close(self, reason: str) -> None:
         """Emit ``StreamAborted`` unless a durable event committed the id.
 
@@ -211,6 +241,9 @@ class StreamContext:
                 self.new_attempt()
         self._chunk_id = chunk_id
         if not self._started:
+            if self._anchor_pending and self._last_seq is not None:
+                self._anchor_seq = self._last_seq()
+                self._anchor_pending = False
             self._started = self._opened = True
             self._started_attempt = self._attempt
             self._emit(StreamStarted(self.item_id, self._attempt, self._anchor_seq))

{openhands_sdk-1.59.0 → openhands_sdk-1.60.0}/openhands/sdk/agent/utils.py

@@ -26,7 +26,11 @@ from openhands.sdk.context.condenser.base import CondenserBase
 from openhands.sdk.context.view import View
 from openhands.sdk.event.base import LLMConvertibleEvent
 from openhands.sdk.event.condenser import Condensation
-from openhands.sdk.llm import LLM, Message
+from openhands.sdk.llm import LLM, Message, TextContent
+from openhands.sdk.llm.mixins.fn_call_converter import (
+    TERMINAL_COMMAND_PREFIX_ALIASES,
+    TOOL_NAME_ALIASES,
+)
 
 
 # Regex matching raw ASCII control characters (U+0000–U+001F) that are
@@ -240,17 +244,6 @@ def fix_malformed_tool_arguments(
     return fixed_arguments
 
 
-TOOL_NAME_ALIASES: dict[str, str] = {
-    "bash": "terminal",
-    "command": "terminal",
-    "execute": "terminal",
-    "execute_bash": "terminal",
-    "git": "terminal",
-    "reset": "terminal",
-    "str_replace": "file_editor",
-    "str_replace_editor": "file_editor",
-}
-
 # Regex to detect malformed tool names (e.g., "str_replace </parameter"
 # or "str_replace</function>"). These occur when LLMs emit XML/HTML
 # tag fragments in tool names. The leading identifier is extracted and
@@ -270,12 +263,6 @@ def _extract_tool_name_base(tool_name: str) -> str:
     return match.group(1) if match else tool_name
 
 
-# Terminal aliases that prepend the tool name to the command argument.
-# Unlike 'bash' which passes through the command directly, these tools
-# (e.g., 'git', 'reset') are themselves commands that should be combined
-# with their arguments (e.g., 'git status', 'reset clear').
-_TERMINAL_COMMAND_PREFIX_ALIASES = frozenset({"git", "reset"})
-
 # This fallback is intentionally tiny: it only accepts exact, bare command names
 # that are useful as read-only defaults when some models emit them as tool names.
 _SHELL_TOOL_FALLBACK_COMMANDS = frozenset({"find", "git", "ls", "pwd"})
@@ -506,7 +493,7 @@ def normalize_tool_call(
             # For terminal alias with prefix, combine tool name with command
             if (
                 alias_target == "terminal"
-                and base_name in _TERMINAL_COMMAND_PREFIX_ALIASES
+                and base_name in TERMINAL_COMMAND_PREFIX_ALIASES
             ):
                 original_command = arguments.get("command")
                 normalized_arguments = {
@@ -560,6 +547,34 @@ def normalize_tool_call(
     return normalized_tool_name, normalized_arguments
 
 
+_TRAILING_ASSISTANT_NUDGE = (
+    "Your previous response has already been delivered to the user. If the user "
+    "sent a new message above that your previous response did not address, "
+    "respond to it now. Otherwise, continue the task."
+)
+
+
+def _ensure_trailing_user_message(messages: list[Message]) -> None:
+    """Append a request-only user turn when the history ends with the assistant.
+
+    A user message that lands while the LLM call is in flight is recorded before
+    the agent's reply (``astep`` releases the state lock for the network wait),
+    so the continued run would otherwise send ``[..., user, assistant]``. Chat
+    APIs expect the final turn to be a user turn, and Anthropic rejects a
+    trailing assistant message on models without prefill support. The nudge is
+    not persisted: it only shapes this request.
+    """
+    if not messages or messages[-1].role != "assistant":
+        return
+    logger.warning(
+        "LLM history ends with an assistant message; appending a user turn so "
+        "the request does not end with assistant prefill."
+    )
+    messages.append(
+        Message(role="user", content=[TextContent(text=_TRAILING_ASSISTANT_NUDGE)])
+    )
+
+
 @overload
 def prepare_llm_messages(
     view: View,
@@ -630,6 +645,7 @@ def prepare_llm_messages(
     if additional_messages:
         messages.extend(additional_messages)
 
+    _ensure_trailing_user_message(messages)
     return messages
 
 
@@ -665,4 +681,5 @@ async def aprepare_llm_messages(
     if additional_messages:
         messages.extend(additional_messages)
 
+    _ensure_trailing_user_message(messages)
     return messages

{openhands_sdk-1.59.0 → openhands_sdk-1.60.0}/openhands/sdk/context/prompts/sections/static.py

@@ -19,6 +19,9 @@ from openhands.sdk.context.prompts.section import (
     Platform,
     PromptContext,
 )
+from openhands.sdk.llm.utils.openhands_provider import (
+    OPENHANDS_SYSTEM_IDENTITY,
+)
 from openhands.sdk.utils.path import get_user_persistence_dir, to_posix_path
 
 
@@ -81,10 +84,7 @@ class _StaticTextSection:
 class SoulSection(_StaticTextSection):
     name = "soul"
 
-    _DEFAULT_SOUL = (
-        "You are OpenHands agent, a helpful AI assistant that can interact"
-        " with a computer to solve tasks."
-    )
+    _DEFAULT_SOUL = OPENHANDS_SYSTEM_IDENTITY
 
     def render(self, ctx: PromptContext) -> str | None:
         soul = str(ctx.template_kwargs.get("soul_content") or self._DEFAULT_SOUL)

{openhands_sdk-1.59.0 → openhands_sdk-1.60.0}/openhands/sdk/conversation/base.py

@@ -258,6 +258,13 @@ class BaseConversation(ABC):
 
         This method runs the agent until it finishes processing the current
         message or reaches the maximum iteration limit.
+
+        When the run ends because the iteration limit is reached
+        (``ERROR``) or the agent is stuck (``STUCK``), the implementations
+        differ: ``LocalConversation.run()`` returns and leaves that status in
+        ``state.execution_status``, while ``RemoteConversation.run()`` raises
+        :class:`ConversationRunError`. Errors raised during the run, such as
+        LLM errors, raise ``ConversationRunError`` in both.
         """
         ...
 
@@ -472,10 +479,10 @@ class BaseConversation(ABC):
                 if ``None``).
             agent: Agent for the fork. Defaults to a deep-copy of the
                 source agent.
-            title: Deprecated on ``LocalConversation`` since 1.54.0 — has no
-                effect there and emits a ``DeprecationWarning``. Still
-                honoured by ``RemoteConversation`` (passed to the agent
-                server which stores it on ``StoredConversation``).
+            title: Honoured by ``RemoteConversation`` (passed to the agent
+                server which stores it on ``StoredConversation``); accepted
+                but ignored by ``LocalConversation``, which has no title
+                field.
             tags: Optional tags for the forked conversation.
             reset_metrics: If ``True`` (default), cost/token stats start
                 fresh on the fork.

{openhands_sdk-1.59.0 → openhands_sdk-1.60.0}/openhands/sdk/conversation/event_store.py

@@ -339,11 +339,7 @@ class EventLog(EventsListBase):
         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 posix_path_name(p).startswith("event-") and p.endswith(".json")
-        )
+        return sum(1 for p in paths if EVENT_NAME_RE.match(posix_path_name(p)))
 
     def _sync_from_disk(self, disk_length: int) -> None:
         """Sync state for events written by other processes.