openhands-sdk 1.29.2__tar.gz → 1.30.0__tar.gz

{openhands_sdk-1.29.2 → openhands_sdk-1.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-sdk
-Version: 1.29.2
+Version: 1.30.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.29.2 → openhands_sdk-1.30.0}/openhands/sdk/__init__.py

@@ -85,6 +85,7 @@ from openhands.sdk.skills import (
 )
 from openhands.sdk.subagent import (
     agent_definition_to_factory,
+    discover_agents,
     load_agents_from_dir,
     load_project_agents,
     load_user_agents,
@@ -197,6 +198,7 @@ __all__ = [
     "load_project_agents",
     "load_user_agents",
     "load_agents_from_dir",
+    "discover_agents",
     "agent_definition_to_factory",
     "load_project_skills",
     "load_skills_from_dir",

{openhands_sdk-1.29.2 → openhands_sdk-1.30.0}/openhands/sdk/agent/agent.py

@@ -27,7 +27,7 @@ from openhands.sdk.agent.utils import (
     parse_tool_call_arguments,
     prepare_llm_messages,
 )
-from openhands.sdk.context.prompts.presets import create_registry
+from openhands.sdk.context.prompts.presets import PromptPreset, create_registry
 from openhands.sdk.conversation import (
     CancellationToken,
     ConversationCallbackType,
@@ -51,6 +51,7 @@ from openhands.sdk.event.condenser import (
     CondensationRequest,
 )
 from openhands.sdk.llm import (
+    LLM,
     LLMResponse,
     Message,
     MessageToolCall,
@@ -61,9 +62,11 @@ from openhands.sdk.llm import (
 )
 from openhands.sdk.llm.exceptions import (
     FunctionCallValidationError,
+    LLMContentPolicyViolationError,
     LLMContextWindowExceedError,
     LLMMalformedConversationHistoryError,
 )
+from openhands.sdk.llm.router.base import RouterLLM
 from openhands.sdk.logger import get_logger
 from openhands.sdk.observability.laminar import (
     maybe_init_laminar,
@@ -78,6 +81,7 @@ from openhands.sdk.tool import (
 
 
 if TYPE_CHECKING:
+    from openhands.sdk.llm.llm import LLMCallContext
     from openhands.sdk.tool import ToolDefinition
 from openhands.sdk.mcp.tool import MCPToolDefinition
 from openhands.sdk.tool.builtins import (
@@ -112,6 +116,36 @@ def _tool_has_summary_param(tool: ToolDefinition) -> bool:
 INIT_STATE_PREFIX_SCAN_WINDOW = 3
 
 
+def _latest_user_message_contains_image(messages: list[Message]) -> bool:
+    for message in reversed(messages):
+        if message.role == "user":
+            return message.contains_image
+    return False
+
+
+def _non_multimodal_image_message(model: str) -> Message:
+    return Message(
+        role="assistant",
+        content=[
+            TextContent(
+                text=(
+                    "I received your image, but the currently selected model "
+                    f"({model}) does not support image understanding. Please "
+                    "switch to a multimodal model to analyze the image."
+                )
+            )
+        ],
+    )
+
+
+def _should_handle_non_multimodal_image_input(
+    llm: LLM, messages: list[Message]
+) -> bool:
+    if isinstance(llm, RouterLLM):
+        return False
+    return _latest_user_message_contains_image(messages) and not llm.vision_is_active()
+
+
 @dataclass(frozen=True, slots=True)
 class _ActionBatch:
     """Immutable result of preparing a batch of actions for execution.
@@ -473,7 +507,10 @@ class Agent(CriticMixin, ResponseDispatchMixin, AgentBase):
         secret_infos = state.secret_registry.get_secret_infos()
 
         ctx = self._build_prompt_context(additional_secret_infos=secret_infos)
-        return create_registry().build(ctx).dynamic
+        # The dynamic tier is preset-independent; fall back to the default tier for a
+        # custom Jinja template (preset None), as before.
+        preset = self._prompt_preset or PromptPreset.DEFAULT
+        return create_registry(preset).build(ctx).dynamic
 
     def _execute_actions(
         self,
@@ -571,6 +608,10 @@ class Agent(CriticMixin, ResponseDispatchMixin, AgentBase):
                 "skipping hook check for legacy conversation state."
             )
 
+        # Build per-conversation context once and thread it through all
+        # LLM calls in this step (avoids shared mutable state on the LLM).
+        call_context: LLMCallContext = conversation.get_llm_call_context()
+
         # Prepare LLM messages from the cached, incrementally-maintained view.
         # See https://github.com/OpenHands/software-agent-sdk/issues/3053.
         _messages_or_condensation = prepare_llm_messages(
@@ -584,6 +625,20 @@ class Agent(CriticMixin, ResponseDispatchMixin, AgentBase):
 
         _messages = _messages_or_condensation
 
+        if _should_handle_non_multimodal_image_input(self.llm, _messages):
+            logger.info(
+                "Image input received while selected model does not support vision: %s",
+                self.llm.model,
+            )
+            on_event(
+                MessageEvent(
+                    source="agent",
+                    llm_message=_non_multimodal_image_message(self.llm.model),
+                )
+            )
+            state.execution_status = ConversationExecutionStatus.FINISHED
+            return
+
         logger.debug(
             "Sending messages to LLM: "
             f"{json.dumps([m.model_dump() for m in _messages[1:]], indent=2)}"
@@ -595,6 +650,7 @@ class Agent(CriticMixin, ResponseDispatchMixin, AgentBase):
                 _messages,
                 tools=list(self.tools_map.values()),
                 on_token=on_token,
+                call_context=call_context,
             )
         except FunctionCallValidationError as e:
             logger.warning(f"LLM generated malformed function call: {e}")
@@ -607,6 +663,28 @@ class Agent(CriticMixin, ResponseDispatchMixin, AgentBase):
             )
             on_event(error_message)
             return
+        except LLMContentPolicyViolationError as e:
+            # Content-policy blocks are deterministic; nudge the model and let the
+            # run loop continue instead of emitting a fatal error.
+            logger.warning(f"LLM output blocked by content filter: {e}")
+            on_event(
+                MessageEvent(
+                    source="user",
+                    llm_message=Message(
+                        role="user",
+                        content=[
+                            TextContent(
+                                text=(
+                                    "Your previous response was blocked by the "
+                                    "model's content filter. Please continue, "
+                                    "rephrasing to avoid the flagged content."
+                                )
+                            )
+                        ],
+                    ),
+                )
+            )
+            return
         except LLMMalformedConversationHistoryError as e:
             # The provider rejected the current message history as structurally
             # invalid (for example, broken tool_use/tool_result pairing). Route
@@ -712,6 +790,8 @@ class Agent(CriticMixin, ResponseDispatchMixin, AgentBase):
                 "skipping hook check for legacy conversation state."
             )
 
+        call_context: LLMCallContext = conversation.get_llm_call_context()
+
         # Prepare LLM messages from the cached, incrementally-maintained view.
         # See https://github.com/OpenHands/software-agent-sdk/issues/3053.
         _messages_or_condensation = await aprepare_llm_messages(
@@ -724,6 +804,20 @@ class Agent(CriticMixin, ResponseDispatchMixin, AgentBase):
 
         _messages = _messages_or_condensation
 
+        if _should_handle_non_multimodal_image_input(self.llm, _messages):
+            logger.info(
+                "Image input received while selected model does not support vision: %s",
+                self.llm.model,
+            )
+            on_event(
+                MessageEvent(
+                    source="agent",
+                    llm_message=_non_multimodal_image_message(self.llm.model),
+                )
+            )
+            state.execution_status = ConversationExecutionStatus.FINISHED
+            return
+
         logger.debug(
             "Sending messages to LLM: "
             f"{json.dumps([m.model_dump() for m in _messages[1:]], indent=2)}"
@@ -735,6 +829,7 @@ class Agent(CriticMixin, ResponseDispatchMixin, AgentBase):
                 _messages,
                 tools=list(self.tools_map.values()),
                 on_token=on_token,
+                call_context=call_context,
             )
         except FunctionCallValidationError as e:
             logger.warning(f"LLM generated malformed function call: {e}")
@@ -747,6 +842,28 @@ class Agent(CriticMixin, ResponseDispatchMixin, AgentBase):
             )
             on_event(error_message)
             return
+        except LLMContentPolicyViolationError as e:
+            # Content-policy blocks are deterministic; nudge the model and let the
+            # run loop continue instead of emitting a fatal error.
+            logger.warning(f"LLM output blocked by content filter: {e}")
+            on_event(
+                MessageEvent(
+                    source="user",
+                    llm_message=Message(
+                        role="user",
+                        content=[
+                            TextContent(
+                                text=(
+                                    "Your previous response was blocked by the "
+                                    "model's content filter. Please continue, "
+                                    "rephrasing to avoid the flagged content."
+                                )
+                            )
+                        ],
+                    ),
+                )
+            )
+            return
         except LLMMalformedConversationHistoryError as e:
             # The provider rejected the current message history as
             # structurally invalid (for example, broken

{openhands_sdk-1.29.2 → openhands_sdk-1.30.0}/openhands/sdk/agent/base.py

@@ -9,6 +9,7 @@ from abc import ABC, abstractmethod
 from collections import Counter
 from collections.abc import Generator, Iterable, Sequence
 from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal
 
 from pydantic import (
@@ -25,7 +26,7 @@ from pydantic import (
 
 from openhands.sdk.context.agent_context import AgentContext
 from openhands.sdk.context.condenser import CondenserBase
-from openhands.sdk.context.prompts.presets import create_registry
+from openhands.sdk.context.prompts.presets import PromptPreset, create_registry
 from openhands.sdk.context.prompts.prompt import render_template
 from openhands.sdk.context.prompts.section import Platform, PromptContext
 from openhands.sdk.critic.base import CriticBase
@@ -110,12 +111,21 @@ _DEFAULT_SOUL = (
     " with a computer to solve tasks."
 )
 
-# Built-in prompt dir. The registry only stands in for the default prompt here; a
-# subclass with its own prompts/system_prompt.j2 keeps the Jinja render path.
+# 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.
 _BUILTIN_PROMPT_DIR = os.path.realpath(
     os.path.join(os.path.dirname(__file__), "prompts")
 )
 
+# Built-in ``system_prompt_filename`` values are back-compat sentinels (the .j2 files
+# were removed) that select a registry preset. ``system_prompt_planning.j2`` keeps its
+# historical name so ``get_planning_agent`` needs no change. Any other filename -- or a
+# subclass's own ``prompt_dir`` -- falls through to the Jinja escape hatch.
+_PRESET_BY_FILENAME: dict[str, PromptPreset] = {
+    "system_prompt.j2": PromptPreset.DEFAULT,
+    "system_prompt_planning.j2": PromptPreset.PLANNING,
+}
+
 
 def _load_soul_md() -> str:
     """Load ``~/.openhands/SOUL.md``, falling back to the built-in default."""
@@ -248,10 +258,14 @@ class AgentBase(DiscriminatedUnionMixin, ABC):
     security_policy_filename: str = Field(
         default="security_policy.j2",
         description=(
-            "Security policy template filename. Can be either:\n"
-            "- A relative filename (e.g., 'security_policy.j2') loaded from the "
-            "agent's prompts directory\n"
-            "- An absolute path (e.g., '/path/to/custom_security_policy.j2')\n"
+            "Security policy filename. The default 'security_policy.j2' is a "
+            "back-compat sentinel (the file was removed) that selects the built-in "
+            "default policy from the prompt registry -- it is not loaded from disk. "
+            "Any other value names a custom policy file whose contents are inserted "
+            "verbatim (NOT rendered as a Jinja template). Can be either:\n"
+            "- A relative filename (e.g., 'custom_security_policy.md') loaded from "
+            "the agent's prompts directory\n"
+            "- An absolute path (e.g., '/path/to/custom_security_policy.md')\n"
             "- Empty string to disable security policy"
         ),
     )
@@ -456,6 +470,18 @@ class AgentBase(DiscriminatedUnionMixin, ABC):
         """Returns the name of the Agent."""
         return self.__class__.__name__
 
+    @property
+    def _prompt_preset(self) -> PromptPreset | None:
+        """The registry preset for this agent's built-in prompt.
+
+        ``None`` means "take the Jinja escape hatch": a subclass with its own
+        ``prompt_dir``, or a ``system_prompt_filename`` that is not a known built-in
+        sentinel (e.g. a custom relative name or an absolute path).
+        """
+        if os.path.realpath(self.prompt_dir) != _BUILTIN_PROMPT_DIR:
+            return None
+        return _PRESET_BY_FILENAME.get(self.system_prompt_filename)
+
     @property
     def static_system_message(self) -> str:
         """Compute the static portion of the system message.
@@ -464,12 +490,11 @@ class AgentBase(DiscriminatedUnionMixin, ABC):
         per-conversation context. This static portion can be cached and reused
         across conversations for better prompt caching efficiency.
 
-        The default prompt is assembled from the typed section registry
-        (``create_registry``). Escape hatches keep the Jinja render path: an inline
-        ``system_prompt`` is returned verbatim; a custom/absolute
-        ``system_prompt_filename`` renders through ``render_template``; a subclass
-        with its own ``prompt_dir`` still renders its default-named template; and a
-        custom ``security_policy_filename`` renders so its policy file is included.
+        Built-in prompts (the ``default`` and ``planning`` presets) are assembled from
+        the typed section registry, which also resolves a custom
+        ``security_policy_filename``. Escape hatches keep the Jinja path: an inline
+        ``system_prompt`` is returned verbatim; a custom ``system_prompt_filename`` or
+        subclass ``prompt_dir`` renders its own template.
 
         Returns:
             The static system prompt without dynamic context.
@@ -477,22 +502,17 @@ class AgentBase(DiscriminatedUnionMixin, ABC):
         if self.system_prompt is not None:
             return self.system_prompt
 
-        # Escape hatch: custom/absolute filename, a subclass with its own
-        # prompt_dir, or a custom security policy. The registry reproduces only
-        # the built-in default prompt (default template + default policy); a
-        # non-default security_policy_filename must keep the Jinja include path.
-        if (
-            self.system_prompt_filename != "system_prompt.j2"
-            or os.path.realpath(self.prompt_dir) != _BUILTIN_PROMPT_DIR
-            or self.security_policy_filename != "security_policy.j2"
-        ):
+        # Escape hatch: a custom filename or a subclass's own prompt_dir renders its
+        # own Jinja template; everything else (incl. custom policies) uses the registry.
+        preset = self._prompt_preset
+        if preset is None:
             return render_template(
                 prompt_dir=self.prompt_dir,
                 template_name=self.system_prompt_filename,
                 **self._resolved_template_kwargs(),
             )
 
-        return create_registry().build(self._build_prompt_context()).static
+        return create_registry(preset).build(self._build_prompt_context()).static
 
     def _resolved_template_kwargs(self) -> dict[str, object]:
         """Resolve the system-prompt template kwargs.
@@ -525,6 +545,24 @@ class AgentBase(DiscriminatedUnionMixin, ABC):
                 template_kwargs["model_variant"] = spec.variant
         return template_kwargs
 
+    def _read_custom_security_policy(self) -> str | None:
+        """Raw contents of a custom security policy file -- inserted verbatim, NOT
+        rendered as a Jinja template.
+
+        Returns ``None`` -- so ``SecuritySection`` keeps its built-in default policy
+        -- when ``security_policy_filename`` is the default sentinel
+        ``"security_policy.j2"`` (a string only; the file was removed, so it is never
+        read) or ``""`` (an empty *filename*, which disables the policy). A configured
+        file whose own contents are empty still returns ``""`` (an empty custom
+        policy), not ``None``.
+
+        Relative names resolve against ``prompt_dir``; absolute paths are used as-is.
+        """
+        filename = self.security_policy_filename
+        if not filename or filename == "security_policy.j2":
+            return None
+        return (Path(self.prompt_dir) / filename).read_text(encoding="utf-8")
+
     def _build_prompt_context(
         self,
         additional_secret_infos: list[dict[str, str | None]] | None = None,
@@ -578,8 +616,17 @@ class AgentBase(DiscriminatedUnionMixin, ABC):
             # secrets (additional_secret_infos), matching what <CUSTOM_SECRETS> shows.
             secret_names = tuple(name for name, _ in secret_infos if name)
 
+        template_kwargs = self._resolved_template_kwargs()
+        # A custom security policy's content for SecuritySection (registry path only).
+        policy_content = self._read_custom_security_policy()
+        if policy_content is not None:
+            template_kwargs = {
+                **template_kwargs,
+                "security_policy_content": policy_content,
+            }
+
         return PromptContext(
-            template_kwargs=self._resolved_template_kwargs(),
+            template_kwargs=template_kwargs,
             tool_names=tuple(t.name for t in self.tools),
             platform=Platform.current(),
             working_dir=None,
@@ -613,7 +660,10 @@ class AgentBase(DiscriminatedUnionMixin, ABC):
         """
         if not self.agent_context:
             return None
-        return create_registry().build(self._build_prompt_context()).dynamic
+        # The dynamic tier is preset-independent, so a custom Jinja template (preset
+        # None) still gets the default dynamic block, exactly as before.
+        preset = self._prompt_preset or PromptPreset.DEFAULT
+        return create_registry(preset).build(self._build_prompt_context()).dynamic
 
     def init_state(
         self,

{openhands_sdk-1.29.2 → openhands_sdk-1.30.0}/openhands/sdk/agent/utils.py

@@ -31,6 +31,7 @@ from openhands.sdk.tool import Action, ToolDefinition
 
 
 if TYPE_CHECKING:
+    from openhands.sdk.llm.llm import LLMCallContext
     from openhands.sdk.llm.streaming import AnyTokenCallbackType
 
 
@@ -604,6 +605,7 @@ def make_llm_completion(
     messages: list[Message],
     tools: list[ToolDefinition] | None = None,
     on_token: ConversationTokenCallbackType | None = None,
+    call_context: LLMCallContext | None = None,
 ) -> LLMResponse:
     """Make an LLM completion call with the provided messages and tools.
 
@@ -612,6 +614,7 @@ def make_llm_completion(
         messages: The messages to send to the LLM
         tools: Optional list of tools to provide to the LLM
         on_token: Optional callback for streaming token updates
+        call_context: Per-conversation context for cache/session affinity.
 
     Returns:
         LLMResponse from the LLM completion call
@@ -636,6 +639,7 @@ def make_llm_completion(
             store=False,
             add_security_risk_prediction=True,
             on_token=on_token,
+            call_context=call_context,
         )
     else:
         return llm.completion(
@@ -643,6 +647,7 @@ def make_llm_completion(
             tools=tools or [],
             add_security_risk_prediction=True,
             on_token=on_token,
+            call_context=call_context,
         )
 
 
@@ -686,6 +691,7 @@ async def amake_llm_completion(
     messages: list[Message],
     tools: list[ToolDefinition] | None = None,
     on_token: AnyTokenCallbackType | None = None,
+    call_context: LLMCallContext | None = None,
 ) -> LLMResponse:
     """Async variant of :func:`make_llm_completion`."""
     if llm.uses_responses_api():
@@ -696,6 +702,7 @@ async def amake_llm_completion(
             store=False,
             add_security_risk_prediction=True,
             on_token=on_token,
+            call_context=call_context,
         )
     else:
         return await llm.acompletion(
@@ -703,4 +710,5 @@ async def amake_llm_completion(
             tools=tools or [],
             add_security_risk_prediction=True,
             on_token=on_token,
+            call_context=call_context,
         )

{openhands_sdk-1.29.2 → openhands_sdk-1.30.0}/openhands/sdk/context/agent_context.py

@@ -16,6 +16,8 @@ from pydantic import (
 )
 
 from openhands.sdk.context.prompts import render_template
+from openhands.sdk.context.prompts.presets import create_registry
+from openhands.sdk.context.prompts.section import PromptContext
 from openhands.sdk.llm import Message, TextContent
 from openhands.sdk.llm.utils.model_prompt_spec import get_model_prompt_spec
 from openhands.sdk.logger import get_logger
@@ -41,8 +43,8 @@ PROMPT_DIR = pathlib.Path(__file__).parent / "prompts" / "templates"
 
 
 class ResolvedDynamicData(NamedTuple):
-    """Dynamic-tier inputs resolved once, shared by the legacy ``.j2`` renderer and
-    the section registry (skills gated by model family, secrets merged)."""
+    """Dynamic-tier inputs resolved once, fed into the section registry
+    (skills gated by model family, secrets merged)."""
 
     repo_skills: list[Skill]
     available_skills_prompt: str
@@ -116,7 +118,8 @@ class AgentContext(BaseModel):
         default_factory=list,
         description=(
             "Marketplace registrations for plugin resolution. Registrations with "
-            "auto_load=True are resolved by LocalConversation at startup."
+            "auto_load=True or a list of plugin names are resolved by "
+            "LocalConversation at startup."
         ),
         json_schema_extra={"acp_compatible": True},
     )
@@ -147,8 +150,8 @@ class AgentContext(BaseModel):
         json_schema_extra={"acp_compatible": True},
     )
     current_datetime: datetime | str | None = Field(
-        # Timezone-aware local "now" so the value injected into the system prompt
-        # carries a UTC offset instead of an ambiguous naive local time (#3438).
+        # Timezone-aware local "now"; get_formatted_datetime renders it to the
+        # minute for the prompt.
         default_factory=lambda: datetime.now().astimezone(),
         description=(
             "Current date and time information to provide to the agent. "
@@ -263,13 +266,17 @@ class AgentContext(BaseModel):
 
         Returns:
             Formatted datetime string, or None if current_datetime is not set.
-            If current_datetime is a datetime object, it's formatted as ISO 8601.
+            If current_datetime is a datetime object, it's formatted as
+            "YYYY-MM-DDTHH:MM" (no seconds, microseconds, or UTC offset).
             If current_datetime is already a string, it's returned as-is.
         """
         if self.current_datetime is None:
             return None
         if isinstance(self.current_datetime, datetime):
-            return self.current_datetime.isoformat()
+            # Local wall-clock to the minute: drop seconds, microseconds, offset.
+            return self.current_datetime.replace(tzinfo=None).isoformat(
+                timespec="minutes"
+            )
         return self.current_datetime
 
     def _partition_skills(self) -> tuple[list[Skill], list[Skill]]:
@@ -327,27 +334,16 @@ class AgentContext(BaseModel):
         data = self._resolve_dynamic_data(
             llm_model, llm_model_canonical, additional_secret_infos
         )
-        has_content = (
-            data.repo_skills
-            or self.system_message_suffix
-            or data.secret_infos
-            or data.available_skills_prompt
-            or data.formatted_datetime
+        ctx = PromptContext(
+            now=data.formatted_datetime,
+            repo_skills=tuple((s.name, s.content) for s in data.repo_skills),
+            available_skills_prompt=data.available_skills_prompt or None,
+            custom_suffix=self.system_message_suffix or None,
+            secret_infos=tuple(
+                (info["name"] or "", info["description"]) for info in data.secret_infos
+            ),
         )
-        if has_content:
-            formatted_text = render_template(
-                prompt_dir=str(PROMPT_DIR),
-                template_name="system_message_suffix.j2",
-                repo_skills=data.repo_skills,
-                system_message_suffix=self.system_message_suffix or "",
-                secret_infos=data.secret_infos,
-                available_skills_prompt=data.available_skills_prompt,
-                current_datetime=data.formatted_datetime,
-            ).strip()
-            return formatted_text
-        elif self.system_message_suffix and self.system_message_suffix.strip():
-            return self.system_message_suffix.strip()
-        return None
+        return create_registry().build(ctx).dynamic
 
     def _resolve_dynamic_data(
         self,
@@ -433,9 +429,10 @@ class AgentContext(BaseModel):
         this adapter only emits prompt-only context.  Unsupported AgentContext
         fields are rejected by :meth:`validate_acp_compatibility`.
 
-        The rendering reuses :meth:`get_system_message_suffix` with the same
-        ``system_message_suffix.j2`` template so that ACP agents receive the
-        identical prompt layout as the regular agent.  This includes the
+        The rendering reuses :meth:`get_system_message_suffix`, which assembles
+        the dynamic-tier sections via the shared prompt registry, so that ACP
+        agents receive the identical prompt layout as the regular agent.  This
+        includes the
         ``<CUSTOM_SECRETS>`` block when secrets are present, informing the ACP
         subprocess which environment variables are available.  The actual secret
         values are injected into the subprocess environment by
@@ -455,7 +452,8 @@ class AgentContext(BaseModel):
         """
         self.validate_acp_compatibility()
         # No model-specific skill filtering for ACP — delegate to the shared
-        # renderer which also renders the <CUSTOM_SECRETS> block from secrets.
+        # builder, whose dynamic-tier sections also emit the <CUSTOM_SECRETS>
+        # block from secrets.
         return self.get_system_message_suffix(
             additional_secret_infos=additional_secret_infos
         )

{openhands_sdk-1.29.2 → openhands_sdk-1.30.0}/openhands/sdk/context/condenser/llm_summarizing_condenser.py

@@ -80,6 +80,16 @@ class LLMSummarizingCondenser(RollingCondenser):
             )
         return self
 
+    @model_validator(mode="after")
+    def _disable_streaming_for_summary(self):
+        # Summaries are consumed whole with no on_token callback, which a
+        # streaming LLM requires. Disable streaming once so every summary path
+        # is covered. model_copy is non-mutating and shares usage_id/metrics,
+        # so summary tokens stay attributed to the conversation.
+        if self.llm.stream:
+            self.llm = self.llm.model_copy(update={"stream": False})
+        return self
+
     def handles_condensation_requests(self) -> bool:
         return True