openhands-sdk 1.54.0__tar.gz → 1.55.0__tar.gz

{openhands_sdk-1.54.0 → openhands_sdk-1.55.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-sdk
-Version: 1.54.0
+Version: 1.55.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

{openhands_sdk-1.54.0 → openhands_sdk-1.55.0}/openhands/sdk/conversation/base.py

@@ -444,7 +444,10 @@ class BaseConversation(ABC):
                 if ``None``).
             agent: Agent for the fork. Defaults to a deep-copy of the
                 source agent.
-            title: Optional title for the forked conversation.
+            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``).
             tags: Optional tags for the forked conversation.
             reset_metrics: If ``True`` (default), cost/token stats start
                 fresh on the fork.

{openhands_sdk-1.54.0 → openhands_sdk-1.55.0}/openhands/sdk/conversation/impl/local_conversation.py

@@ -112,6 +112,7 @@ from openhands.sdk.tool.builtins import InvokeSkillTool
 from openhands.sdk.tool.client_tool import ClientToolSpec
 from openhands.sdk.tool.schema import Action, Observation
 from openhands.sdk.utils.cipher import Cipher
+from openhands.sdk.utils.deprecation import warn_deprecated
 from openhands.sdk.workspace import LocalWorkspace
 
 
@@ -204,6 +205,7 @@ class LocalConversation(BaseConversation):
     _plugins_loaded: bool
     _pending_hook_config: HookConfig | None  # Hook config to combine with plugin hooks
     _mcp_tool_provider: MCPToolProvider
+    _mcp_config_from_parent: bool
     _llm_call_context: LLMCallContext
 
     def __init__(
@@ -243,6 +245,7 @@ class LocalConversation(BaseConversation):
         profile_store_dir: str | Path | None = None,
         stream_callbacks: list[StreamProgressCallbackType] | None = None,
         _parent_llm_call_context: LLMCallContext | None = None,
+        _mcp_config_from_parent: bool = False,
         **_: object,
     ):
         """Initialize the conversation.
@@ -305,6 +308,9 @@ class LocalConversation(BaseConversation):
                 for state and EventLog storage.
             _parent_llm_call_context: Runtime LLM context inherited by an internal
                 child conversation. Conversation-local identity is always replaced.
+            _mcp_config_from_parent: The agent's ``mcp_config`` is the resolved
+                config of a delegating parent. It is used as-is: no plugin MCP
+                servers are merged into it and no ``${VAR}`` is expanded again.
             profile_store_dir: Optional directory containing saved LLM profiles.
                 Defaults to ``~/.openhands/profiles``.
         """
@@ -325,6 +331,7 @@ class LocalConversation(BaseConversation):
         self._pending_hook_config = hook_config  # Will be combined with plugin hooks
         self._agent_ready = False  # Agent initialized lazily after plugins loaded
         self._mcp_tool_provider = mcp_tool_provider or DefaultMCPToolProvider()
+        self._mcp_config_from_parent = _mcp_config_from_parent
 
         # Create-or-resume: factory inspects BASE_STATE to decide
         desired_id = conversation_id or uuid.uuid4()
@@ -815,7 +822,10 @@ class LocalConversation(BaseConversation):
                 if ``None``).
             agent: Agent for the fork. Defaults to a deep-copy of the
                 source agent.
-            title: Optional title for the forked conversation.
+            title: Deprecated. ``LocalConversation`` has no title field;
+                ``ConversationState`` does not store titles (they live on
+                ``StoredConversation`` in the agent-server layer). Passing a
+                value is accepted for backwards compatibility but has no effect.
             tags: Optional tags for the forked conversation.
             reset_metrics: If ``True`` (default), cost/token stats start
                 fresh on the fork.
@@ -830,6 +840,17 @@ class LocalConversation(BaseConversation):
         Raises:
             ValueError: If ``from_event_id`` is not an event in this conversation.
         """
+        if title is not None:
+            warn_deprecated(
+                "LocalConversation.fork() title parameter",
+                deprecated_in="1.54.0",
+                removed_in="1.60.0",
+                details=(
+                    "LocalConversation has no title field; titles are managed by "
+                    "StoredConversation in the agent-server layer."
+                ),
+                stacklevel=2,
+            )
         fork_id = conversation_id or uuid.uuid4()
         # Always deep-copy the agent (supplied or source) so the fork owns
         # its own object graph. Required because __init__ binds
@@ -911,13 +932,6 @@ class LocalConversation(BaseConversation):
             )
             fork_conv._state.agent_state = copy.deepcopy(self._state.agent_state)
 
-            # Copy title via tags if provided
-            if title is not None:
-                fork_conv._state.tags = {
-                    **fork_conv._state.tags,
-                    "title": title,
-                }
-
             # Reset or copy metrics
             if not reset_metrics:
                 fork_conv._state.stats = self._state.stats.model_copy(deep=True)
@@ -1215,7 +1229,9 @@ class LocalConversation(BaseConversation):
         # - This is the ONLY place where defaults are applied (plugin loading preserves
         #   placeholders with expand_defaults=False to avoid double-expansion)
         # Agent Plugins servers are left literal (see expand_mcp_servers).
-        if merged_mcp:
+        if self._mcp_config_from_parent:
+            merged_mcp = dict(self.agent.mcp_config)
+        elif merged_mcp:
             # Pass the registry's lookup method as a callback - secrets are retrieved
             # lazily, one at a time, only when actually referenced in the config
             merged_mcp = expand_mcp_servers(

{openhands_sdk-1.54.0 → openhands_sdk-1.55.0}/openhands/sdk/conversation/impl/remote_conversation.py

@@ -1787,8 +1787,6 @@ class RemoteConversation(BaseConversation):
             self.agent.model_dump(context={"expose_secrets": True}),
         )
 
-        # Use server-returned tags (which include merged title) rather than
-        # the input tags, so the client-side object stays consistent.
         server_tags: dict[str, str] | None = fork_info.get("tags") or None
 
         return RemoteConversation(

openhands_sdk-1.55.0/openhands/sdk/conversation/message_request.py

@@ -0,0 +1,19 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from openhands.sdk.llm.message import ImageContent, Message, TextContent
+
+
+class SendMessageRequest(BaseModel):
+    """Payload to send a message to the agent."""
+
+    role: Literal["user", "system", "assistant", "tool"] = "user"
+    content: list[TextContent | ImageContent] = Field(default_factory=list)
+    run: bool = Field(
+        default=False,
+        description="Whether the agent loop should automatically run if not running",
+    )
+
+    def create_message(self) -> Message:
+        return Message(role=self.role, content=self.content)

{openhands_sdk-1.54.0 → openhands_sdk-1.55.0}/openhands/sdk/conversation/request.py

@@ -8,7 +8,7 @@ agent-server.
 
 from __future__ import annotations
 
-from typing import Annotated, Any, Literal, cast
+from typing import Annotated, Any, cast
 from uuid import UUID
 
 from pydantic import (
@@ -24,6 +24,9 @@ from pydantic import (
 from openhands.sdk.agent.acp_agent import ACPAgent as ACPAgent
 from openhands.sdk.agent.agent import Agent as Agent
 from openhands.sdk.agent.base import AgentBase
+from openhands.sdk.conversation.message_request import (
+    SendMessageRequest as SendMessageRequest,
+)
 from openhands.sdk.conversation.types import (
     ConversationObservabilityMetadata,
     ConversationObservabilitySpanName,
@@ -31,7 +34,6 @@ from openhands.sdk.conversation.types import (
     ConversationTags,
 )
 from openhands.sdk.hooks import HookConfig
-from openhands.sdk.llm.message import ImageContent, Message, TextContent
 from openhands.sdk.plugin import PluginSource
 from openhands.sdk.secret import SecretSource
 from openhands.sdk.security.analyzer import SecurityAnalyzerBase
@@ -39,6 +41,8 @@ from openhands.sdk.security.confirmation_policy import (
     ConfirmationPolicyBase,
     NeverConfirm,
 )
+from openhands.sdk.settings.model import validate_agent_settings
+from openhands.sdk.skills import Skill
 from openhands.sdk.subagent.schema import AgentDefinition
 from openhands.sdk.tool.client_tool import ClientToolSpec
 from openhands.sdk.utils.models import kind_of
@@ -61,20 +65,6 @@ ACPEnabledAgent = Annotated[
 # ---------------------------------------------------------------------------
 
 
-class SendMessageRequest(BaseModel):
-    """Payload to send a message to the agent."""
-
-    role: Literal["user", "system", "assistant", "tool"] = "user"
-    content: list[TextContent | ImageContent] = Field(default_factory=list)
-    run: bool = Field(
-        default=False,
-        description="Whether the agent loop should automatically run if not running",
-    )
-
-    def create_message(self) -> Message:
-        return Message(role=self.role, content=self.content)
-
-
 class AgentLaunchAdditions(BaseModel):
     """Add deployment context after agent resolution."""
 
@@ -88,6 +78,30 @@ class AgentLaunchAdditions(BaseModel):
             "system-message suffix."
         ),
     )
+    skills: list[Skill] | None = Field(
+        default=None,
+        exclude_if=lambda value: value is None,
+        description=(
+            "Deployment-supplied skills merged into the resolved agent's "
+            "context. For a client that ships its own skill catalog and so "
+            "cannot rely on the server's: an ``agent_profile_id`` launch sends "
+            "no ``agent_settings``, leaving it no other way to supply them. "
+            "Merged by name — a skill the resolved agent already carries wins, "
+            "and the profile's ``disabled_skills`` deny-list still applies, so "
+            "this cannot reintroduce something the profile turned off. None "
+            "(the default) adds nothing."
+        ),
+    )
+    llm_profile_ref: str | None = Field(
+        default=None,
+        min_length=1,
+        description=(
+            "LLM profile to launch an OpenHands Agent Profile with instead of "
+            "its own `llm_profile_ref`. Recorded in `launched_agent_profile`; "
+            "the stored profile is not modified. Only valid with "
+            "`agent_profile_id`."
+        ),
+    )
 
 
 class ConversationConfig(BaseModel):
@@ -291,9 +305,10 @@ class StartConversationRequest(ConversationConfig):
     """Payload to create a new conversation.
 
     Extends :class:`ConversationConfig` with the agent source: a stored Agent
-    Profile (``agent_profile_id``), resolved agent settings (``agent_settings``),
-    or an ``agent`` built in code. The server builds the conversation's agent
-    from that source at launch; this model only validates it.
+    Profile (``agent_profile_id``), resolved agent settings
+    (``agent_settings``), or an ``agent`` built in code. The
+    server turns the source into the conversation's agent at launch; this model
+    only checks that exactly one source is given.
 
     Note: the agent lives here on the *request*, deliberately not on
     ``ConversationConfig``. The persisted record (``StoredConversation``) does
@@ -313,7 +328,7 @@ class StartConversationRequest(ConversationConfig):
         default=None,
         description=(
             "Stored Agent Profile to launch. The server resolves it with its own "
-            "stores. Mutually exclusive with `agent` and `agent_settings`."
+            "stores. Mutually exclusive with the other agent sources."
         ),
     )
     agent: AgentBase = Field(default=cast(AgentBase, None))
@@ -323,25 +338,26 @@ class StartConversationRequest(ConversationConfig):
     def _normalize_agent_source(cls, data: Any) -> Any:
         if not isinstance(data, dict):
             return data
-        # ``agent`` has no nullable type of its own; a null means "not this source".
+        # An explicit null means "not this source"; ``agent`` has no nullable
+        # type of its own.
         payload = {
             name: value
             for name, value in data.items()
-            if name != "agent" or value is not None
+            if value is not None or name not in ("agent", "agent_settings")
         }
-        has_profile_id = payload.get("agent_profile_id") is not None
-        has_agent = payload.get("agent") is not None
-        has_agent_settings = payload.get("agent_settings") is not None
-        if has_profile_id and (has_agent or has_agent_settings):
+        other_sources = [
+            name
+            for name in ("agent", "agent_settings")
+            if payload.get(name) is not None
+        ]
+        if payload.get("agent_profile_id") is not None and other_sources:
             raise ValueError(
-                "`agent_profile_id` is mutually exclusive with"
-                " `agent` and `agent_settings`"
+                "`agent_profile_id` is mutually exclusive with "
+                + ", ".join(f"`{name}`" for name in other_sources)
             )
-        if has_agent:
+        if payload.get("agent") is not None:
             payload["agent_settings"] = None
-        if not has_agent and has_agent_settings:
-            from openhands.sdk.settings.model import validate_agent_settings
-
+        if payload.get("agent") is None and payload.get("agent_settings") is not None:
             try:
                 validate_agent_settings(payload["agent_settings"])
             except (TypeError, ValueError) as exc:
@@ -355,14 +371,16 @@ class StartConversationRequest(ConversationConfig):
 
     @model_validator(mode="after")
     def _require_agent(self) -> StartConversationRequest:
-        if (
-            self.agent is None
-            and self.agent_settings is None
-            and self.agent_profile_id is None
-        ):
+        has_profile = self.agent_profile_id is not None
+        if not has_profile and self.agent is None and self.agent_settings is None:
+            raise ValueError(
+                "One of `agent`, `agent_settings`, or `agent_profile_id` must be"
+                " provided"
+            )
+        additions = self.agent_launch_additions
+        if additions is not None and additions.llm_profile_ref and not has_profile:
             raise ValueError(
-                "One of `agent`, `agent_settings`, or"
-                " `agent_profile_id` must be provided"
+                "`agent_launch_additions.llm_profile_ref` requires `agent_profile_id`"
             )
         return self
 

{openhands_sdk-1.54.0 → openhands_sdk-1.55.0}/openhands/sdk/extensions/fetch.py

@@ -23,7 +23,7 @@ class SourceType(StrEnum):
 
     LOCAL   -- a filesystem path (absolute, home-relative, or dot-relative).
     GIT     -- any git-clonable URL (HTTPS, SSH, git://, etc.).
-    GITHUB  -- the ``github:owner/repo`` shorthand, expanded to an HTTPS URL.
+    GITHUB  -- the ``github:owner/repo[/path]`` shorthand, expanded to an HTTPS URL.
     """
 
     LOCAL = "local"
@@ -31,12 +31,30 @@ class SourceType(StrEnum):
     GITHUB = "github"
 
 
+def _split_github_shorthand(source: str) -> tuple[str, str | None]:
+    """Split ``github:owner/repo[/subpath]`` into ``("owner/repo", subpath)``.
+
+    Raises:
+        ExtensionFetchError: If owner or repo is missing.
+    """
+    owner, _, rest = source.strip()[len("github:") :].partition("/")
+    repo, _, subpath = rest.partition("/")
+    if not owner or not repo:
+        raise ExtensionFetchError(
+            f"Invalid GitHub shorthand format: {source}. "
+            f"Expected format: github:owner/repo[/path]"
+        )
+    return f"{owner}/{repo}", subpath.strip("/") or None
+
+
 def parse_extension_source(source: str) -> tuple[SourceType, str]:
     """Parse extension source into (SourceType, url).
 
     Args:
         source: Extension source string. Can be:
             - "github:owner/repo" - GitHub repository shorthand
+            - "github:owner/repo/path" - the same, naming a subdirectory
+              (fetch() uses the path as ``repo_path``)
             - "https://github.com/owner/repo.git" - Full git URL
             - "git@github.com:owner/repo.git" - SSH git URL
             - "/local/path" - Local path
@@ -57,16 +75,10 @@ def parse_extension_source(source: str) -> tuple[SourceType, str]:
     """
     source = source.strip()
 
-    # GitHub shorthand: github:owner/repo
+    # GitHub shorthand: github:owner/repo[/subpath]
     if source.startswith("github:"):
-        repo_path = source[7:]  # Remove "github:" prefix
-        # Validate format
-        if "/" not in repo_path or repo_path.count("/") > 1:
-            raise ExtensionFetchError(
-                f"Invalid GitHub shorthand format: {source}. "
-                f"Expected format: github:owner/repo"
-            )
-        url = f"https://github.com/{repo_path}.git"
+        repo, _ = _split_github_shorthand(source)
+        url = f"https://github.com/{repo}.git"
         return (SourceType.GITHUB, url)
 
     # Git URLs: detect by protocol/scheme rather than enumerating providers
@@ -194,6 +206,16 @@ def fetch_with_resolution(
     """
     source_type, url = parse_extension_source(source)
 
+    if source_type == SourceType.GITHUB:
+        _, subpath = _split_github_shorthand(source)
+        if subpath is not None:
+            if repo_path:
+                raise ExtensionFetchError(
+                    f"GitHub shorthand {source} already names a subdirectory; "
+                    "do not also pass repo_path"
+                )
+            repo_path = subpath
+
     if source_type == SourceType.LOCAL:
         base_path = _resolve_local_source(url)
         return _apply_subpath(base_path, repo_path, f"local source '{source}'"), None

{openhands_sdk-1.54.0 → openhands_sdk-1.55.0}/openhands/sdk/extensions/installation/manager.py

@@ -1,10 +1,15 @@
 from __future__ import annotations
 
 import shutil
+import tempfile
 from dataclasses import dataclass
 from pathlib import Path
 
-from openhands.sdk.extensions.fetch import fetch_with_resolution
+from openhands.sdk.extensions.fetch import (
+    SourceType,
+    fetch_with_resolution,
+    parse_extension_source,
+)
 from openhands.sdk.extensions.installation.info import InstallationInfo
 from openhands.sdk.extensions.installation.interface import (
     ExtensionProtocol,
@@ -15,6 +20,7 @@ from openhands.sdk.extensions.installation.metadata import (
     MetadataSession,
 )
 from openhands.sdk.extensions.installation.utils import validate_extension_name
+from openhands.sdk.git.utils import extract_repo_name
 from openhands.sdk.logger import get_logger
 from openhands.sdk.utils.path import get_user_persistence_dir
 from openhands.sdk.utils.redact import redact_url_credentials
@@ -82,6 +88,23 @@ class InstallationManager[T: ExtensionProtocol]:
             FileExistsError: If extension is already installed and force=False.
             ValueError: If the extension name is invalid.
         """
+        return self._install(source, ref=ref, repo_path=repo_path, force=force)
+
+    def _install(
+        self,
+        source: str | Path,
+        ref: str | None = None,
+        repo_path: str | None = None,
+        force: bool = False,
+        root_name: str | None = None,
+    ) -> InstallationInfo:
+        """Install as ``install`` does; ``root_name`` names a repository root.
+
+        ``root_name`` replaces the repository's name as the directory name a
+        remote source without ``repo_path`` is loaded from (see
+        ``_load_fetched``).  ``update`` passes the installed name, so an
+        extension installed under another name keeps it.
+        """
         if isinstance(source, Path):
             source = str(source)
 
@@ -94,7 +117,7 @@ class InstallationManager[T: ExtensionProtocol]:
             update=True,
         )
 
-        extension = self.installation_interface.load_from_dir(fetched_path)
+        extension = self._load_fetched(fetched_path, source, repo_path, root_name)
         validate_extension_name(extension.name)
 
         install_path = self.installation_dir / extension.name
@@ -132,6 +155,34 @@ class InstallationManager[T: ExtensionProtocol]:
         )
         return info
 
+    def _load_fetched(
+        self,
+        fetched_path: Path,
+        source: str,
+        repo_path: str | None,
+        root_name: str | None = None,
+    ) -> T:
+        """Load the fetched extension, named after its repository if it is one.
+
+        A remote source without ``repo_path`` is fetched to the root of its
+        clone cache, ``<repo>-<hash>``.  A loader that infers the name from the
+        directory (a plugin without a manifest) must see ``<repo>`` instead, as
+        it would for a local directory, so load from a copy with that name.
+        """
+        source_type, url = parse_extension_source(source)
+        if repo_path or source_type == SourceType.LOCAL:
+            return self.installation_interface.load_from_dir(fetched_path)
+
+        with tempfile.TemporaryDirectory() as staging:
+            load_path = Path(staging) / (root_name or extract_repo_name(url))
+            shutil.copytree(
+                fetched_path,
+                load_path,
+                symlinks=True,
+                ignore=shutil.ignore_patterns(".git"),
+            )
+            return self.installation_interface.load_from_dir(load_path)
+
     def uninstall(self, name: str) -> bool:
         """Uninstall an extension by name.
 
@@ -297,7 +348,8 @@ class InstallationManager[T: ExtensionProtocol]:
         Re-fetches the extension from its original source with ``ref=None``
         (i.e. the latest available) and force-reinstalls it.  The previous
         ``enabled`` state is preserved because ``install(force=True)``
-        carries it over.
+        carries it over.  A repository root without a manifest keeps its
+        installed name.
 
         Args:
             name: Name of the extension to update.
@@ -319,9 +371,10 @@ class InstallationManager[T: ExtensionProtocol]:
 
         redacted = redact_url_credentials(current_info.source)
         logger.info(f"Updating extension {name} from {redacted}")
-        return self.install(
+        return self._install(
             source=current_info.source,
             ref=None,
             repo_path=current_info.repo_path,
             force=True,
+            root_name=name,
         )

{openhands_sdk-1.54.0 → openhands_sdk-1.55.0}/openhands/sdk/git/cached_repo.py

@@ -201,6 +201,7 @@ def try_cached_clone_or_update(
     update: bool = True,
     git_helper: GitHelper | None = None,
     lock_timeout: float = DEFAULT_LOCK_TIMEOUT,
+    strict: bool = False,
 ) -> Path | None:
     """Clone or update a git repository in a cache directory.
 
@@ -227,6 +228,9 @@ def try_cached_clone_or_update(
         update: If True and repo exists, fetch and update it. If False, skip fetch.
         git_helper: GitHelper instance for git operations. If None, creates one.
         lock_timeout: Timeout in seconds for acquiring the lock. Default is 5 minutes.
+        strict: If True, an update whose fetch (or checkout of ``ref`` after the
+            fetch) fails returns None instead of the stale cached repository.
+            The cached repository is left on disk either way.
 
     Returns:
         Path to the local repository if successful, None on failure.
@@ -243,7 +247,7 @@ def try_cached_clone_or_update(
 
     try:
         with lock.acquire(timeout=lock_timeout):
-            return _do_clone_or_update(url, repo_path, ref, update, git)
+            return _do_clone_or_update(url, repo_path, ref, update, git, strict)
     except Timeout:
         logger.warning(
             f"Timed out waiting for lock on {repo_path} after {lock_timeout}s"
@@ -263,6 +267,7 @@ def _do_clone_or_update(
     ref: str | None,
     update: bool,
     git: GitHelper,
+    strict: bool = False,
 ) -> Path:
     """Perform the actual clone or update operation (called while holding lock).
 
@@ -272,6 +277,7 @@ def _do_clone_or_update(
         ref: Branch, tag, or commit to checkout.
         update: Whether to update existing repos.
         git: GitHelper instance.
+        strict: Whether a failed update raises instead of keeping the cache.
 
     Returns:
         Path to the repository.
@@ -282,7 +288,7 @@ def _do_clone_or_update(
     if repo_path.exists() and (repo_path / ".git").exists():
         if update:
             logger.debug(f"Updating repository at {repo_path}")
-            _update_repository(repo_path, ref, git)
+            _update_repository(repo_path, ref, git, strict=strict)
         elif ref:
             logger.debug(f"Checking out ref {ref} at {repo_path}")
             _checkout_ref(repo_path, ref, git)
@@ -329,6 +335,7 @@ def _update_repository(
     repo_path: Path,
     ref: str | None,
     git: GitHelper,
+    strict: bool = False,
 ) -> None:
     """Update an existing cached repository to the latest remote state.
 
@@ -354,6 +361,8 @@ def _update_repository(
         ref: Branch, tag, or commit to update to. If None, uses current branch
             or falls back to the remote's default branch.
         git: GitHelper instance.
+        strict: If True, a failed fetch, or a failed checkout of ``ref`` after
+            the fetch, raises ``GitCommandError`` instead of keeping the cache.
     """
     if ref:
         # Optimistically attempt a local checkout before touching the network.
@@ -367,13 +376,19 @@ def _update_repository(
         except GitCommandError:
             pass  # ref not cached locally; fall through to fetch
 
-    # Fetch from origin - if this fails, we still have a usable (stale) cache
-    if not _try_fetch(repo_path, git):
+    # Fetch from origin - if this fails, we still have a usable (stale) cache;
+    # strict callers need to know the update did not happen.
+    if strict:
+        git.fetch(repo_path)
+    elif not _try_fetch(repo_path, git):
         return
 
     # If a specific ref was requested, check it out
     if ref:
-        _try_checkout_and_reset(repo_path, ref, git)
+        if strict:
+            _checkout_ref(repo_path, ref, git)
+        else:
+            _try_checkout_and_reset(repo_path, ref, git)
         return
 
     # No ref specified - update based on current state

{openhands_sdk-1.54.0 → openhands_sdk-1.55.0}/openhands/sdk/git/git_diff.py

@@ -108,8 +108,14 @@ def get_git_diff(relative_file_path: str | Path, ref: str | None = None) -> GitD
 
     # Get old content (from the ref)
     try:
-        original = run_git_command(
-            ["git", "show", f"{current_rev}:{relative_path_from_repo}"], validated_repo
+        # Read the blob verbatim and normalize it like the modified side below,
+        # so an unchanged file keeps its edge whitespace on both sides.
+        original = "\n".join(
+            run_git_command(
+                ["git", "show", f"{current_rev}:{relative_path_from_repo}"],
+                validated_repo,
+                strip=False,
+            ).splitlines()
         )
     except GitCommandError:
         logger.debug(f"No old content found for {path} at ref {current_rev}")