openhands-sdk 1.4.0__tar.gz → 1.5.0__tar.gz

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-sdk
-Version: 1.4.0
+Version: 1.5.0
 Summary: OpenHands SDK - Core functionality for building AI agents
 Requires-Python: >=3.12
 Requires-Dist: deprecation>=2.1.0

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/openhands/sdk/agent/agent.py

@@ -186,7 +186,7 @@ class Agent(AgentBase):
             )
             on_event(error_message)
             return
-        except LLMContextWindowExceedError:
+        except LLMContextWindowExceedError as e:
             # If condenser is available and handles requests, trigger condensation
             if (
                 self.condenser is not None
@@ -197,8 +197,9 @@ class Agent(AgentBase):
                 )
                 on_event(CondensationRequest())
                 return
-            # No condenser available; re-raise for client handling
-            raise
+            # No condenser available or doesn't handle requests; log helpful warning
+            self._log_context_window_exceeded_warning()
+            raise e
 
         # LLMResponse already contains the converted message and metrics snapshot
         message: Message = llm_response.message
@@ -516,3 +517,98 @@ class Agent(AgentBase):
                 ]["token_ids"],
             )
             on_event(token_event)
+
+    def _log_context_window_exceeded_warning(self) -> None:
+        """Log a helpful warning when context window is exceeded without a condenser."""
+        if self.condenser is None:
+            logger.warning(
+                "\n"
+                "=" * 80 + "\n"
+                "⚠️  CONTEXT WINDOW EXCEEDED ERROR\n"
+                "=" * 80 + "\n"
+                "\n"
+                "The LLM's context window has been exceeded, but no condenser is "
+                "configured.\n"
+                "\n"
+                "Current configuration:\n"
+                f"  • Condenser: None\n"
+                f"  • LLM Model: {self.llm.model}\n"
+                "\n"
+                "To prevent this error, configure a condenser to automatically "
+                "summarize\n"
+                "conversation history when it gets too long.\n"
+                "\n"
+                "Example configuration:\n"
+                "\n"
+                "  from openhands.sdk import Agent, LLM\n"
+                "  from openhands.sdk.context.condenser import "
+                "LLMSummarizingCondenser\n"
+                "\n"
+                "  agent = Agent(\n"
+                "      llm=LLM(model='your-model'),\n"
+                "      condenser=LLMSummarizingCondenser(\n"
+                "          llm=LLM(model='your-model'),  # Can use same or "
+                "cheaper model\n"
+                "          max_size=120,  # Maximum events before condensation\n"
+                "          keep_first=4   # Number of initial events to preserve\n"
+                "      )\n"
+                "  )\n"
+                "\n"
+                "For more information, see: "
+                "https://docs.openhands.dev/sdk/guides/context-condenser\n"
+                "=" * 80
+            )
+        else:
+            condenser_type = type(self.condenser).__name__
+            handles_requests = self.condenser.handles_condensation_requests()
+            condenser_config = self.condenser.model_dump(
+                exclude={"llm"}, exclude_none=True
+            )
+            condenser_llm_obj = getattr(self.condenser, "llm", None)
+            condenser_llm = (
+                condenser_llm_obj.model if condenser_llm_obj is not None else "N/A"
+            )
+
+            logger.warning(
+                "\n"
+                "=" * 80 + "\n"
+                "⚠️  CONTEXT WINDOW EXCEEDED ERROR\n"
+                "=" * 80 + "\n"
+                "\n"
+                "The LLM's context window has been exceeded.\n"
+                "\n"
+                "Current configuration:\n"
+                f"  • Condenser Type: {condenser_type}\n"
+                f"  • Handles Condensation Requests: {handles_requests}\n"
+                f"  • Condenser LLM: {condenser_llm}\n"
+                f"  • Agent LLM Model: {self.llm.model}\n"
+                f"  • Condenser Config: {json.dumps(condenser_config, indent=4)}\n"
+                "\n"
+                "Your condenser is configured but does not handle condensation "
+                "requests\n"
+                "(handles_condensation_requests() returned False).\n"
+                "\n"
+                "To fix this:\n"
+                "  1. Use LLMSummarizingCondenser which handles condensation "
+                "requests, OR\n"
+                "  2. Implement handles_condensation_requests() in your custom "
+                "condenser\n"
+                "\n"
+                "Example with LLMSummarizingCondenser:\n"
+                "\n"
+                "  from openhands.sdk.context.condenser import "
+                "LLMSummarizingCondenser\n"
+                "\n"
+                "  agent = Agent(\n"
+                "      llm=LLM(model='your-model'),\n"
+                "      condenser=LLMSummarizingCondenser(\n"
+                "          llm=LLM(model='your-model'),\n"
+                "          max_size=120,\n"
+                "          keep_first=4\n"
+                "      )\n"
+                "  )\n"
+                "\n"
+                "For more information, see: "
+                "https://docs.openhands.dev/sdk/guides/context-condenser\n"
+                "=" * 80
+            )

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/openhands/sdk/agent/prompts/system_prompt.j2

@@ -52,6 +52,7 @@ You are OpenHands agent, a helpful AI assistant that can interact with a compute
    * For bug fixes: Create tests to verify issues before implementing fixes
    * For new features: Consider test-driven development when appropriate
    * Do NOT write tests for documentation changes, README updates, configuration files, or other non-functionality changes
+   * Do not use mocks in tests unless strictly necessary and justify their use when they are used. You must always test real code paths in tests, NOT mocks.
    * If the repository lacks testing infrastructure and implementing tests would require extensive setup, consult with the user before investing time in building testing infrastructure
    * If the environment is not set up to run tests, consult with the user first before investing time to install all dependencies
 4. IMPLEMENTATION:

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/openhands/sdk/context/agent_context.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 import pathlib
+from collections.abc import Mapping
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 
@@ -11,6 +14,7 @@ from openhands.sdk.context.skills import (
 )
 from openhands.sdk.llm import Message, TextContent
 from openhands.sdk.logger import get_logger
+from openhands.sdk.secret import SecretValue
 
 
 logger = get_logger(__name__)
@@ -65,6 +69,15 @@ class AgentContext(BaseModel):
             "This allows you to get the latest skills without SDK updates."
         ),
     )
+    secrets: Mapping[str, SecretValue] | None = Field(
+        default=None,
+        description=(
+            "Dictionary mapping secret keys to values or secret sources. "
+            "Secrets are used for authentication and sensitive data handling. "
+            "Values can be either strings or SecretSource instances "
+            "(str | SecretSource)."
+        ),
+    )
 
     @field_validator("skills")
     @classmethod
@@ -123,6 +136,16 @@ class AgentContext(BaseModel):
             logger.warning(f"Failed to load public skills: {str(e)}")
         return self
 
+    def get_secret_names(self) -> list[str]:
+        """Get the list of secret names from the secrets field.
+
+        Returns:
+            List of secret names. Returns an empty list if no secrets are configured.
+        """
+        if not self.secrets:
+            return []
+        return list(self.secrets.keys())
+
     def get_system_message_suffix(self) -> str | None:
         """Get the system message with repo skill content and custom suffix.
 
@@ -135,13 +158,15 @@ class AgentContext(BaseModel):
         repo_skills = [s for s in self.skills if s.trigger is None]
         logger.debug(f"Triggered {len(repo_skills)} repository skills: {repo_skills}")
         # Build the workspace context information
-        if repo_skills:
+        secret_names = self.get_secret_names()
+        if repo_skills or self.system_message_suffix or secret_names:
             # TODO(test): add a test for this rendering to make sure they work
             formatted_text = render_template(
                 prompt_dir=str(PROMPT_DIR),
                 template_name="system_message_suffix.j2",
                 repo_skills=repo_skills,
                 system_message_suffix=self.system_message_suffix or "",
+                secret_names=secret_names,
             ).strip()
             return formatted_text
         elif self.system_message_suffix and self.system_message_suffix.strip():

openhands_sdk-1.5.0/openhands/sdk/context/prompts/templates/system_message_suffix.j2

@@ -0,0 +1,32 @@
+{% if repo_skills %}
+<REPO_CONTEXT>
+The following information has been included based on several files defined in user's repository.
+Please follow them while working.
+
+{% for agent_info in repo_skills %}
+[BEGIN context from [{{ agent_info.name }}]]
+{{ agent_info.content }}
+[END Context]
+{% endfor %}
+</REPO_CONTEXT>
+{% endif %}
+{% if system_message_suffix %}
+
+{{ system_message_suffix }}
+{% endif %}
+{% if secret_names %}
+<CUSTOM_SECRETS>
+### Credential Access
+* Automatic secret injection: When you reference a registered secret key in your bash command, the secret value will be automatically exported as an environment variable before your command executes.
+* How to use secrets: Simply reference the secret key in your command (e.g., `echo ${GITHUB_TOKEN:0:8}` or `curl -H "Authorization: Bearer $API_KEY" https://api.example.com`). The system will detect the key name in your command text and export it as environment variable before it executes your command.
+* Secret detection: The system performs case-insensitive matching to find secret keys in your command text. If a registered secret key appears anywhere in your command, its value will be made available as an environment variable.
+* Security: Secret values are automatically masked in command output to prevent accidental exposure. You will see `<secret-hidden>` instead of the actual secret value in the output.
+* Refreshing expired secrets: Some secrets (like GITHUB_TOKEN) may be updated periodically or expire over time. If a secret stops working (e.g., authentication failures), try using it again in a new command - the system should automatically use the refreshed value. For example, if GITHUB_TOKEN was used in a git remote URL and later expired, you can update the remote URL with the current token: `git remote set-url origin https://${GITHUB_TOKEN}@github.com/username/repo.git` to pick up the refreshed token value.
+* If it still fails, report it to the user.
+
+You have access to the following environment variables
+{% for secret_name in secret_names %}
+* **${{ secret_name }}**
+{% endfor %}
+</CUSTOM_SECRETS>
+{% endif %}

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/openhands/sdk/conversation/conversation.py

@@ -3,7 +3,6 @@ from typing import TYPE_CHECKING, Self, overload
 
 from openhands.sdk.agent.base import AgentBase
 from openhands.sdk.conversation.base import BaseConversation
-from openhands.sdk.conversation.secret_registry import SecretValue
 from openhands.sdk.conversation.types import (
     ConversationCallbackType,
     ConversationID,
@@ -14,6 +13,7 @@ from openhands.sdk.conversation.visualizer import (
     DefaultConversationVisualizer,
 )
 from openhands.sdk.logger import get_logger
+from openhands.sdk.secret import SecretValue
 from openhands.sdk.workspace import LocalWorkspace, RemoteWorkspace
 
 

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/openhands/sdk/conversation/conversation_stats.py

@@ -1,4 +1,6 @@
-from pydantic import BaseModel, Field, PrivateAttr
+from typing import Any
+
+from pydantic import BaseModel, Field, PrivateAttr, model_serializer
 
 from openhands.sdk.llm.llm_registry import RegistryEvent
 from openhands.sdk.llm.utils.metrics import Metrics
@@ -18,6 +20,41 @@ class ConversationStats(BaseModel):
 
     _restored_usage_ids: set[str] = PrivateAttr(default_factory=set)
 
+    @model_serializer(mode="wrap")
+    def _serialize_with_context(self, serializer: Any, info: Any) -> dict[str, Any]:
+        """Serialize metrics based on context.
+
+        By default, preserves full metrics history including costs,
+        response_latencies, and token_usages lists for persistence.
+
+        When context={'use_snapshot': True} is passed, converts Metrics to
+        MetricsSnapshot format to minimize payload size for network transmission.
+
+        Args:
+            serializer: Pydantic's default serializer
+            info: Serialization info containing context
+
+        Returns:
+            Dictionary with metrics serialized based on context
+        """
+        # Get the default serialization
+        data = serializer(self)
+
+        # Check if we should use snapshot serialization
+        context = info.context if info else None
+        use_snapshot = context.get("use_snapshot", False) if context else False
+
+        if use_snapshot and "usage_to_metrics" in data:
+            # Replace each Metrics with its snapshot
+            usage_to_snapshots = {}
+            for usage_id, metrics in self.usage_to_metrics.items():
+                snapshot = metrics.get_snapshot()
+                usage_to_snapshots[usage_id] = snapshot.model_dump()
+
+            data["usage_to_metrics"] = usage_to_snapshots
+
+        return data
+
     def get_combined_metrics(self) -> Metrics:
         total_metrics = Metrics()
         for metrics in self.usage_to_metrics.values():

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/openhands/sdk/conversation/secret_registry.py

@@ -4,18 +4,13 @@ from collections.abc import Mapping
 
 from pydantic import Field, PrivateAttr, SecretStr
 
-from openhands.sdk.conversation.secret_source import (
-    SecretSource,
-    StaticSecret,
-)
 from openhands.sdk.logger import get_logger
+from openhands.sdk.secret import SecretSource, SecretValue, StaticSecret
 from openhands.sdk.utils.models import OpenHandsModel
 
 
 logger = get_logger(__name__)
 
-SecretValue = str | SecretSource
-
 
 class SecretRegistry(OpenHandsModel):
     """Manages secrets and injects them into bash commands when needed.

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/openhands/sdk/event/conversation_state.py

@@ -49,6 +49,14 @@ class ConversationStateUpdateEvent(Event):
 
     @field_validator("value")
     def validate_value(cls, value, info):
+        # Prevent circular import
+        from openhands.sdk.conversation.conversation_stats import ConversationStats
+
+        # For ConversationStats, use snapshot serialization to avoid
+        # sending lengthy lists over WebSocket
+        if isinstance(value, ConversationStats):
+            return value.model_dump(mode="json", context={"use_snapshot": True})
+
         key = info.data.get("key")
         if key is None:
             # Allow value without key for flexibility

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/openhands/sdk/llm/llm.py

@@ -260,7 +260,7 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
         "Requires verified OpenAI organization. Only sent when explicitly set.",
     )
     enable_encrypted_reasoning: bool = Field(
-        default=False,
+        default=True,
         description="If True, ask for ['reasoning.encrypted_content'] "
         "in Responses API include.",
     )
@@ -315,7 +315,9 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
     # =========================================================================
     # Internal fields (excluded from dumps)
     # =========================================================================
-    retry_listener: SkipJsonSchema[Callable[[int, int], None] | None] = Field(
+    retry_listener: SkipJsonSchema[
+        Callable[[int, int, BaseException | None], None] | None
+    ] = Field(
         default=None,
         exclude=True,
     )
@@ -369,8 +371,9 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
         if model_val.startswith("openhands/"):
             model_name = model_val.removeprefix("openhands/")
             d["model"] = f"litellm_proxy/{model_name}"
-            # Set base_url (default to the app proxy when base_url is unset)
-            d["base_url"] = d.get("base_url", "https://llm-proxy.app.all-hands.dev/")
+            # Set base_url (default to the app proxy when base_url is unset or None)
+            # Use `or` instead of dict.get() to handle explicit None values
+            d["base_url"] = d.get("base_url") or "https://llm-proxy.app.all-hands.dev/"
 
         # HF doesn't support the OpenAI default value for top_p (1)
         if model_val.startswith("huggingface"):
@@ -426,6 +429,14 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
         )
         return self
 
+    def _retry_listener_fn(
+        self, attempt_number: int, num_retries: int, _err: BaseException | None
+    ) -> 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)
+
     # =========================================================================
     # Serializers
     # =========================================================================
@@ -559,7 +570,7 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
             retry_min_wait=self.retry_min_wait,
             retry_max_wait=self.retry_max_wait,
             retry_multiplier=self.retry_multiplier,
-            retry_listener=self.retry_listener,
+            retry_listener=self._retry_listener_fn,
         )
         def _one_attempt(**retry_kwargs) -> ModelResponse:
             assert self._telemetry is not None
@@ -671,7 +682,6 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
                 "kwargs": {k: v for k, v in call_kwargs.items()},
                 "context_window": self.max_input_tokens or 0,
             }
-        self._telemetry.on_request(log_ctx=log_ctx)
 
         # Perform call with retries
         @self.retry_decorator(
@@ -680,9 +690,11 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
             retry_min_wait=self.retry_min_wait,
             retry_max_wait=self.retry_max_wait,
             retry_multiplier=self.retry_multiplier,
-            retry_listener=self.retry_listener,
+            retry_listener=self._retry_listener_fn,
         )
         def _one_attempt(**retry_kwargs) -> ResponsesAPIResponse:
+            assert self._telemetry is not None
+            self._telemetry.on_request(log_ctx=log_ctx)
             final_kwargs = {**call_kwargs, **retry_kwargs}
             with self._litellm_modify_params_ctx(self.modify_params):
                 with warnings.catch_warnings():
@@ -713,7 +725,6 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
                         f"Expected ResponsesAPIResponse, got {type(ret)}"
                     )
                     # telemetry (latency, cost). Token usage mapping we handle after.
-                    assert self._telemetry is not None
                     self._telemetry.on_response(ret)
                     return ret
 
@@ -982,10 +993,8 @@ class LLM(BaseModel, RetryMixin, NonNativeToolCallingMixin):
         """
         msgs = copy.deepcopy(messages)
 
-        # Set only vision flag; skip cache_enabled and force_string_serializer
+        # Determine vision based on model detection
         vision_active = self.vision_is_active()
-        for m in msgs:
-            m.vision_enabled = vision_active
 
         # Assign system instructions as a string, collect input items
         instructions: str | None = None

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/openhands/sdk/llm/options/responses_options.py

@@ -36,9 +36,11 @@ def select_responses_options(
     else:
         out.setdefault("store", False)
 
-    # Include encrypted reasoning if stateless
+    # Include encrypted reasoning only when the user enables it on the LLM,
+    # and only for stateless calls (store=False). Respect user choice.
     include_list = list(include) if include is not None else []
-    if not out.get("store", False):
+
+    if not out.get("store", False) and llm.enable_encrypted_reasoning:
         if "reasoning.encrypted_content" not in include_list:
             include_list.append("reasoning.encrypted_content")
     if include_list:

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/openhands/sdk/llm/utils/retry_mixin.py

@@ -16,7 +16,7 @@ from openhands.sdk.logger import get_logger
 logger = get_logger(__name__)
 
 # Helpful alias for listener signature: (attempt_number, max_retries) -> None
-RetryListener = Callable[[int, int], None]
+RetryListener = Callable[[int, int, BaseException | None], None]
 
 
 class RetryMixin:
@@ -41,7 +41,12 @@ class RetryMixin:
             self.log_retry_attempt(retry_state)
 
             if retry_listener is not None:
-                retry_listener(retry_state.attempt_number, num_retries)
+                exc = (
+                    retry_state.outcome.exception()
+                    if retry_state.outcome is not None
+                    else None
+                )
+                retry_listener(retry_state.attempt_number, num_retries, exc)
 
             # If there is no outcome or no exception, nothing to tweak.
             if retry_state.outcome is None:

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/openhands/sdk/llm/utils/telemetry.py

@@ -120,7 +120,7 @@ class Telemetry(BaseModel):
 
         return self.metrics.deep_copy()
 
-    def on_error(self, _err: Exception) -> None:
+    def on_error(self, _err: BaseException) -> None:
         # Stub for error tracking / counters
         return
 

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/openhands/sdk/llm/utils/verified_models.py

@@ -2,6 +2,10 @@ VERIFIED_OPENAI_MODELS = [
     "gpt-5-codex",
     "gpt-5-2025-08-07",
     "gpt-5-mini-2025-08-07",
+    "gpt-5.1",
+    "gpt-5.1-codex",
+    "gpt-5.1-codex-max",
+    "gpt-5.1-codex-mini",
     "o4-mini",
     "gpt-4o",
     "gpt-4o-mini",
@@ -33,20 +37,21 @@ VERIFIED_MISTRAL_MODELS = [
     "devstral-small-2505",
     "devstral-small-2507",
     "devstral-medium-2507",
+    "devstral-2512",
+    "devstral-medium-2512",
 ]
 
 VERIFIED_OPENHANDS_MODELS = [
+    "claude-opus-4-5-20251101",
     "claude-sonnet-4-5-20250929",
+    "gpt-5.1-codex-max",
+    "gpt-5.1-codex",
+    "gpt-5.1",
     "gemini-3-pro-preview",
-    "gpt-5-2025-08-07",
-    "gpt-5-codex",
-    "claude-haiku-4-5-20251001",
-    "claude-opus-4-5-20251101",
+    "deekseek-chat",
     "kimi-k2-thinking",
-    "gpt-5-mini-2025-08-07",
-    "claude-opus-4-1-20250805",
-    "devstral-small-2507",
-    "devstral-medium-2507",
+    "devstral-medium-2512",
+    "devstral-2512",
 ]
 
 

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/openhands/sdk/logger/logger.py

@@ -105,7 +105,14 @@ def setup_logging(
     keep = ENV_BACKUP_COUNT if backup_count is None else backup_count
 
     root = logging.getLogger()
+    old_level = root.level
     root.setLevel(lvl)
+
+    # Set the level for any existing logger with the same intial level
+    for logger in logging.root.manager.loggerDict.values():
+        if isinstance(logger, logging.Logger) and logger.level == old_level:
+            logger.setLevel(lvl)
+
     # Do NOT clear existing handlers; Uvicorn installs these before importing the app.
     # Only add ours if there isn't already a comparable stream handler.
     has_stream = any(isinstance(h, logging.StreamHandler) for h in root.handlers)

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/openhands/sdk/mcp/definition.py

@@ -13,7 +13,7 @@ from openhands.sdk.tool import (
     Observation,
 )
 from openhands.sdk.tool.schema import Action
-from openhands.sdk.utils.visualize import display_dict
+from openhands.sdk.utils.visualize import display_json
 
 
 logger = get_logger(__name__)
@@ -97,7 +97,7 @@ class MCPToolObservation(Observation):
                 # try to see if block.text is a JSON
                 try:
                     parsed = json.loads(block.text)
-                    text.append(display_dict(parsed))
+                    text.append(display_json(parsed))
                     continue
                 except (json.JSONDecodeError, TypeError):
                     text.append(block.text + "\n")

openhands_sdk-1.5.0/openhands/sdk/secret/__init__.py

@@ -0,0 +1,19 @@
+"""Secret management module for handling sensitive data.
+
+This module provides classes and types for managing secrets in OpenHands.
+"""
+
+from openhands.sdk.secret.secrets import (
+    LookupSecret,
+    SecretSource,
+    SecretValue,
+    StaticSecret,
+)
+
+
+__all__ = [
+    "SecretSource",
+    "StaticSecret",
+    "LookupSecret",
+    "SecretValue",
+]

openhands_sdk-1.4.0/openhands/sdk/conversation/secret_source.py → openhands_sdk-1.5.0/openhands/sdk/secret/secrets.py

@@ -1,3 +1,5 @@
+"""Secret sources and types for handling sensitive data."""
+
 from abc import ABC, abstractmethod
 
 import httpx
@@ -84,3 +86,7 @@ def _is_secret_header(key: str):
         if secret in key:
             return True
     return False
+
+
+# Type alias for secret values - can be a plain string or a SecretSource
+SecretValue = str | SecretSource

{openhands_sdk-1.4.0 → openhands_sdk-1.5.0}/openhands/sdk/utils/truncate.py

@@ -29,7 +29,7 @@ def _save_full_content(content: str, save_dir: str, tool_prefix: str) -> str | N
     """Save full content to the specified directory and return the file path."""
 
     save_dir_path = Path(save_dir)
-    save_dir_path.mkdir(exist_ok=True)
+    save_dir_path.mkdir(parents=True, exist_ok=True)
 
     # Generate hash-based filename for deduplication
     content_hash = hashlib.sha256(content.encode("utf-8")).hexdigest()[:8]

openhands_sdk-1.5.0/openhands/sdk/utils/visualize.py

@@ -0,0 +1,58 @@
+from rich.text import Text
+
+
+def display_dict(d) -> Text:
+    """Create a Rich Text representation of a dictionary.
+
+    This function is deprecated. Use display_json instead.
+    """
+    return display_json(d)
+
+
+def display_json(data) -> Text:
+    """Create a Rich Text representation of JSON data.
+
+    Handles dictionaries, lists, strings, numbers, booleans, and None values.
+    """
+    content = Text()
+
+    if isinstance(data, dict):
+        for field_name, field_value in data.items():
+            if field_value is None:
+                continue  # skip None fields
+            content.append(f"\n  {field_name}: ", style="bold")
+            if isinstance(field_value, str):
+                # Handle multiline strings with proper indentation
+                if "\n" in field_value:
+                    content.append("\n")
+                    for line in field_value.split("\n"):
+                        content.append(f"    {line}\n")
+                else:
+                    content.append(f'"{field_value}"')
+            elif isinstance(field_value, (list, dict)):
+                content.append(str(field_value))
+            else:
+                content.append(str(field_value))
+    elif isinstance(data, list):
+        content.append(f"[List with {len(data)} items]\n")
+        for i, item in enumerate(data):
+            content.append(f"  [{i}]: ", style="bold")
+            if isinstance(item, str):
+                content.append(f'"{item}"\n')
+            else:
+                content.append(f"{item}\n")
+    elif isinstance(data, str):
+        # Handle multiline strings with proper indentation
+        if "\n" in data:
+            content.append("String:\n")
+            for line in data.split("\n"):
+                content.append(f"  {line}\n")
+        else:
+            content.append(f'"{data}"')
+    elif data is None:
+        content.append("null")
+    else:
+        # Handle numbers, booleans, and other JSON primitives
+        content.append(str(data))
+
+    return content