openhands 0.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

openhands/sdk/llm/utils/telemetry.py

@@ -1,252 +0,0 @@
-import json
-import os
-import time
-import warnings
-from typing import Any, Optional
-
-from litellm.cost_calculator import completion_cost as litellm_completion_cost
-from litellm.types.utils import CostPerToken, ModelResponse, Usage
-from pydantic import BaseModel, ConfigDict, Field, PrivateAttr
-
-from openhands.sdk.llm.utils.metrics import Metrics
-from openhands.sdk.logger import get_logger
-
-
-logger = get_logger(__name__)
-
-
-class Telemetry(BaseModel):
-    """
-    Handles latency, token/cost accounting, and optional logging.
-    All runtime state (like start times) lives in private attrs.
-    """
-
-    # --- Config fields ---
-    model_name: str = Field(default="unknown", description="Name of the LLM model")
-    log_enabled: bool = Field(default=False, description="Whether to log completions")
-    log_dir: Optional[str] = Field(
-        default=None, description="Directory to write logs if enabled"
-    )
-    input_cost_per_token: float | None = Field(
-        default=None, description="Custom Input cost per token (USD)"
-    )
-    output_cost_per_token: float | None = Field(
-        default=None, description="Custom Output cost per token (USD)"
-    )
-
-    metrics: Metrics = Field(..., description="Metrics collector instance")
-
-    # --- Runtime fields (not serialized) ---
-    _req_start: float = PrivateAttr(default=0.0)
-    _req_ctx: dict[str, Any] = PrivateAttr(default_factory=dict)
-    _last_latency: float = PrivateAttr(default=0.0)
-
-    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True)
-
-    # ---------- Lifecycle ----------
-    def on_request(self, log_ctx: dict | None) -> None:
-        self._req_start = time.time()
-        self._req_ctx = log_ctx or {}
-
-    def on_response(
-        self, resp: ModelResponse, raw_resp: ModelResponse | None = None
-    ) -> Metrics:
-        """
-        Side-effects:
-          - records latency, tokens, cost into Metrics
-          - optionally writes a JSON log file
-        """
-        # 1) latency
-        self._last_latency = time.time() - (self._req_start or time.time())
-        response_id = resp.id
-        self.metrics.add_response_latency(self._last_latency, response_id)
-
-        # 2) cost
-        cost = self._compute_cost(resp)
-        if cost:
-            self.metrics.add_cost(cost)
-
-        # 3) tokens - handle both dict and ModelResponse objects
-        if isinstance(resp, dict):
-            usage = resp.get("usage")
-        else:
-            usage = getattr(resp, "usage", None)
-
-        if usage and self._has_meaningful_usage(usage):
-            self._record_usage(
-                usage, response_id, self._req_ctx.get("context_window", 0)
-            )
-
-        # 4) optional logging
-        if self.log_enabled:
-            self._log_completion(resp, cost, raw_resp=raw_resp)
-
-        return self.metrics.deep_copy()
-
-    def on_error(self, err: Exception) -> None:
-        # Stub for error tracking / counters
-        return
-
-    # ---------- Helpers ----------
-    def _has_meaningful_usage(self, usage) -> bool:
-        """Check if usage has meaningful (non-zero) token counts."""
-        if not usage:
-            return False
-
-        # Handle MagicMock objects safely
-        try:
-            if isinstance(usage, dict):
-                prompt_tokens = usage.get("prompt_tokens", 0) or 0
-                completion_tokens = usage.get("completion_tokens", 0) or 0
-            else:
-                prompt_tokens = getattr(usage, "prompt_tokens", 0) or 0
-                completion_tokens = getattr(usage, "completion_tokens", 0) or 0
-
-            # Convert to int safely (handles MagicMock objects)
-            prompt_tokens = int(prompt_tokens) if str(prompt_tokens).isdigit() else 0
-            completion_tokens = (
-                int(completion_tokens) if str(completion_tokens).isdigit() else 0
-            )
-
-            return prompt_tokens > 0 or completion_tokens > 0
-        except (ValueError, TypeError, AttributeError):
-            return False
-
-    def _record_usage(
-        self, usage: Usage, response_id: str, context_window: int
-    ) -> None:
-        # Handle both dict and Usage objects
-        if isinstance(usage, dict):
-            usage = Usage.model_validate(usage)
-
-        prompt_tokens = usage.prompt_tokens or 0
-        completion_tokens = usage.completion_tokens or 0
-        cache_write = usage._cache_creation_input_tokens or 0
-
-        cache_read = 0
-        prompt_token_details = usage.prompt_tokens_details or None
-        if prompt_token_details and prompt_token_details.cached_tokens:
-            cache_read = prompt_token_details.cached_tokens
-
-        reasoning_tokens = 0
-        completion_tokens_details = usage.completion_tokens_details or None
-        if completion_tokens_details and completion_tokens_details.reasoning_tokens:
-            reasoning_tokens = completion_tokens_details.reasoning_tokens
-
-        self.metrics.add_token_usage(
-            prompt_tokens=prompt_tokens,
-            completion_tokens=completion_tokens,
-            cache_read_tokens=cache_read,
-            cache_write_tokens=cache_write,
-            reasoning_tokens=reasoning_tokens,
-            context_window=context_window,
-            response_id=response_id,
-        )
-
-    def _compute_cost(self, resp: ModelResponse) -> Optional[float]:
-        """Try provider header → litellm direct. Return None on failure."""
-        extra_kwargs = {}
-        if (
-            self.input_cost_per_token is not None
-            and self.output_cost_per_token is not None
-        ):
-            cost_per_token = CostPerToken(
-                input_cost_per_token=self.input_cost_per_token,
-                output_cost_per_token=self.output_cost_per_token,
-            )
-            logger.debug(f"Using custom cost per token: {cost_per_token}")
-            extra_kwargs["custom_cost_per_token"] = cost_per_token
-
-        try:
-            hidden = getattr(resp, "_hidden_params", {}) or {}
-            cost = hidden.get("additional_headers", {}).get(
-                "llm_provider-x-litellm-response-cost"
-            )
-            if cost is not None:
-                return float(cost)
-        except Exception as e:
-            logger.debug(f"Failed to get cost from LiteLLM headers: {e}")
-
-        # move on to litellm cost calculator
-        # Handle model name properly - if it doesn't contain "/", use as-is
-        model_parts = self.model_name.split("/")
-        if len(model_parts) > 1:
-            extra_kwargs["model"] = "/".join(model_parts[1:])
-        else:
-            extra_kwargs["model"] = self.model_name
-        try:
-            return float(
-                litellm_completion_cost(completion_response=resp, **extra_kwargs)
-            )
-        except Exception as e:
-            warnings.warn(f"Cost calculation failed: {e}")
-            return None
-
-    def _log_completion(
-        self,
-        resp: ModelResponse,
-        cost: Optional[float],
-        raw_resp: ModelResponse | None = None,
-    ) -> None:
-        if not self.log_dir:
-            return
-        try:
-            # Only log if directory exists and is writable.
-            # Do not create directories implicitly.
-            if not os.path.isdir(self.log_dir):
-                raise FileNotFoundError(f"log_dir does not exist: {self.log_dir}")
-            if not os.access(self.log_dir, os.W_OK):
-                raise PermissionError(f"log_dir is not writable: {self.log_dir}")
-
-            fname = os.path.join(
-                self.log_dir,
-                f"{self.model_name.replace('/', '__')}-{time.time():.3f}.json",
-            )
-            data = self._req_ctx.copy()
-            data["response"] = resp.model_dump()
-            data["cost"] = float(cost or 0.0)
-            data["timestamp"] = time.time()
-            data["latency_sec"] = self._last_latency
-
-            # Usage summary (prompt, completion, reasoning tokens) for quick inspection
-            try:
-                usage = getattr(resp, "usage", None)
-                if usage:
-                    if isinstance(usage, dict):
-                        usage = Usage.model_validate(usage)
-                    prompt_tokens = int(usage.prompt_tokens or 0)
-                    completion_tokens = int(usage.completion_tokens or 0)
-                    reasoning_tokens = 0
-                    details = usage.completion_tokens_details or None
-                    if details and details.reasoning_tokens:
-                        reasoning_tokens = int(details.reasoning_tokens)
-                    data["usage_summary"] = {
-                        "prompt_tokens": prompt_tokens,
-                        "completion_tokens": completion_tokens,
-                        "reasoning_tokens": reasoning_tokens,
-                    }
-                    if usage.prompt_tokens_details:
-                        data["usage_summary"]["cache_read_tokens"] = int(
-                            usage.prompt_tokens_details.cached_tokens or 0
-                        )
-            except Exception:
-                # Best-effort only; don't fail logging
-                pass
-
-            # Raw response *before* nonfncall -> call conversion
-            if raw_resp:
-                data["raw_response"] = raw_resp
-            # pop duplicated tools
-            if "tool" in data and "tool" in data.get("kwargs", {}):
-                data["kwargs"].pop("tool")
-            with open(fname, "w") as f:
-                f.write(json.dumps(data, default=_safe_json))
-        except Exception as e:
-            warnings.warn(f"Telemetry logging failed: {e}")
-
-
-def _safe_json(obj: Any) -> Any:
-    try:
-        return obj.__dict__
-    except Exception:
-        return str(obj)

openhands/sdk/logger.py

@@ -1,167 +0,0 @@
-# simple_logger.py
-"""
-Minimal logger setup that encourages per-module loggers,
-with Rich for humans and JSON for machines.
-
-Usage:
-    from openhands.sdk.logger import get_logger
-    logger = get_logger(__name__)
-    logger.info("Hello from this module!")
-"""
-
-import logging
-import os
-from logging.handlers import TimedRotatingFileHandler
-
-import litellm
-from pythonjsonlogger.json import JsonFormatter
-from rich.console import Console
-from rich.logging import RichHandler
-
-
-# ========= ENV (loaded at import) =========
-LEVEL_MAP = (
-    logging.getLevelNamesMapping()
-    if hasattr(logging, "getLevelNamesMapping")
-    else logging._nameToLevel
-)
-
-DEBUG = os.environ.get("DEBUG", "false").lower() in {"1", "true", "yes"}
-ENV_LOG_LEVEL_STR = os.getenv("LOG_LEVEL", "INFO").upper()
-ENV_LOG_LEVEL = LEVEL_MAP.get(ENV_LOG_LEVEL_STR, logging.INFO)
-if DEBUG:
-    ENV_LOG_LEVEL = logging.DEBUG
-
-ENV_LOG_TO_FILE = os.getenv("LOG_TO_FILE", "false").lower() in {"1", "true", "yes"}
-ENV_LOG_DIR = os.getenv("LOG_DIR", "logs")
-ENV_ROTATE_WHEN = os.getenv("LOG_ROTATE_WHEN", "midnight")
-ENV_BACKUP_COUNT = int(os.getenv("LOG_BACKUP_COUNT", "7"))
-
-# Rich vs JSON
-ENV_JSON = os.getenv("LOG_JSON", "false").lower() in {"1", "true", "yes"}
-IN_CI = os.getenv("CI", "false").lower() in {"1", "true", "yes"}
-ENV_RICH_TRACEBACKS = os.getenv("LOG_RICH_TRACEBACKS", "true").lower() in {
-    "1",
-    "true",
-    "yes",
-}
-
-
-ENV_AUTO_CONFIG = os.getenv("LOG_AUTO_CONFIG", "true").lower() in {"1", "true", "yes"}
-ENV_DEBUG_LLM = os.getenv("DEBUG_LLM", "false").lower() in {"1", "true", "yes"}
-
-
-# ========= LiteLLM controls =========
-_ENABLE_LITELLM_DEBUG = False
-if ENV_DEBUG_LLM:
-    confirmation = input(
-        (
-            "\n⚠️ WARNING: You are enabling DEBUG_LLM which may expose sensitive "
-            "information like API keys.\nThis should NEVER be enabled in production.\n"
-            "Type 'y' to confirm you understand the risks: "
-        )
-    )
-    if confirmation.lower() == "y":
-        _ENABLE_LITELLM_DEBUG = True
-        litellm.suppress_debug_info = False
-        litellm.set_verbose = True  # type: ignore
-    else:
-        print("DEBUG_LLM disabled due to lack of confirmation")
-        litellm.suppress_debug_info = True
-        litellm.set_verbose = False  # type: ignore
-else:
-    litellm.suppress_debug_info = True
-    litellm.set_verbose = False  # type: ignore
-
-
-def disable_logger(name: str, level: int = logging.CRITICAL) -> None:
-    """Disable or quiet down a specific logger by name."""
-    logger = logging.getLogger(name)
-    logger.setLevel(level)
-    logger.propagate = False
-
-
-# Quiet chatty third-party loggers
-for name in ["litellm", "LiteLLM", "openai"]:
-    disable_logger(name, logging.DEBUG if _ENABLE_LITELLM_DEBUG else logging.WARNING)
-for name in ["httpcore", "httpx", "libtmux"]:
-    disable_logger(name, logging.WARNING)
-
-
-# ========= SETUP =========
-def setup_logging(
-    level: int | None = None,
-    log_to_file: bool | None = None,
-    log_dir: str | None = None,
-    fmt: str | None = None,
-    when: str | None = None,
-    backup_count: int | None = None,
-) -> None:
-    """Configure the root logger. All child loggers inherit this setup."""
-    lvl = ENV_LOG_LEVEL if level is None else level
-    to_file = ENV_LOG_TO_FILE if log_to_file is None else log_to_file
-    directory = ENV_LOG_DIR if log_dir is None else log_dir
-    rotate_when = ENV_ROTATE_WHEN if when is None else when
-    keep = ENV_BACKUP_COUNT if backup_count is None else backup_count
-
-    root = logging.getLogger()
-    root.setLevel(lvl)
-    root.handlers = []  # reset
-
-    if ENV_JSON or IN_CI:
-        # JSON console handler
-        ch = logging.StreamHandler()
-        ch.setLevel(lvl)
-        ch.setFormatter(
-            JsonFormatter(
-                fmt="%(asctime)s %(levelname)s %(name)s "
-                "%(filename)s %(lineno)d %(message)s"
-            )
-        )
-        root.addHandler(ch)
-    else:
-        # Rich console handler
-        rich_handler = RichHandler(
-            console=Console(stderr=True),
-            log_time_format="[%x %H:%M:%S.%f]",
-            omit_repeated_times=False,
-            rich_tracebacks=ENV_RICH_TRACEBACKS,
-        )
-        rich_handler.setFormatter(logging.Formatter("%(message)s"))
-        rich_handler.setLevel(lvl)
-        root.addHandler(rich_handler)
-
-    if to_file:
-        os.makedirs(directory, exist_ok=True)
-        fh = TimedRotatingFileHandler(
-            os.path.join(directory, "app.log"),
-            when=rotate_when,
-            backupCount=keep,
-            encoding="utf-8",
-        )
-        fh.setLevel(lvl)
-        if ENV_JSON:
-            fh.setFormatter(
-                JsonFormatter(
-                    fmt="%(asctime)s %(levelname)s %(name)s "
-                    "%(filename)s %(lineno)d %(message)s"
-                )
-            )
-        else:
-            log_fmt = (
-                fmt
-                or "%(asctime)s - %(levelname)s - %(name)s "
-                "- %(filename)s:%(lineno)d - %(message)s"
-            )
-            fh.setFormatter(logging.Formatter(log_fmt))
-        root.addHandler(fh)
-
-
-def get_logger(name: str) -> logging.Logger:
-    """Return a logger for the given module name."""
-    return logging.getLogger(name)
-
-
-# Auto-configure if desired
-if ENV_AUTO_CONFIG:
-    setup_logging()

openhands/sdk/mcp/__init__.py

@@ -1,20 +0,0 @@
-"""MCP (Model Context Protocol) integration for agent-sdk."""
-
-from openhands.sdk.mcp.client import MCPClient
-from openhands.sdk.mcp.definition import MCPToolObservation
-from openhands.sdk.mcp.tool import (
-    MCPTool,
-    MCPToolExecutor,
-)
-from openhands.sdk.mcp.utils import (
-    create_mcp_tools,
-)
-
-
-__all__ = [
-    "MCPClient",
-    "MCPTool",
-    "MCPToolObservation",
-    "MCPToolExecutor",
-    "create_mcp_tools",
-]

openhands/sdk/mcp/client.py

@@ -1,113 +0,0 @@
-"""Minimal sync helpers on top of fastmcp.Client, preserving original behavior."""
-
-import asyncio
-import inspect
-import threading
-from typing import Any, Callable
-
-from fastmcp import Client as AsyncMCPClient
-
-
-class MCPClient(AsyncMCPClient):
-    """
-    Behaves exactly like fastmcp.Client (same constructor & async API),
-    but owns a background event loop and offers:
-      - call_async_from_sync(awaitable_or_fn, *args, timeout=None, **kwargs)
-      - call_sync_from_async(fn, *args, **kwargs)  # await this from async code
-    """
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self._loop: asyncio.AbstractEventLoop | None = None
-        self._thread: threading.Thread | None = None
-        self._lock = threading.Lock()
-
-    # ---------- loop management ----------
-
-    def _ensure_loop(self) -> asyncio.AbstractEventLoop:
-        with self._lock:
-            if self._loop is not None:
-                return self._loop
-
-            loop = asyncio.new_event_loop()
-
-            def _runner():
-                asyncio.set_event_loop(loop)
-                loop.run_forever()
-
-            t = threading.Thread(target=_runner, daemon=True)
-            t.start()
-            while not loop.is_running():
-                pass
-
-            self._loop = loop
-            self._thread = t
-            return loop
-
-    def _shutdown_loop(self) -> None:
-        with self._lock:
-            loop, t = self._loop, self._thread
-            self._loop = None
-            self._thread = None
-
-        if loop and loop.is_running():
-            try:
-                loop.call_soon_threadsafe(loop.stop)
-            except RuntimeError:
-                pass
-        if t and t.is_alive():
-            t.join(timeout=1.0)
-
-    # ---------- public helpers ----------
-
-    def call_async_from_sync(
-        self,
-        awaitable_or_fn: Callable[..., Any] | Any,
-        *args,
-        timeout: float,
-        **kwargs,
-    ):
-        """
-        Run a coroutine or async function on this client's loop from sync code.
-
-        Usage:
-            mcp.call_async_from_sync(async_fn, arg1, kw=...)
-            mcp.call_async_from_sync(coro)
-        """
-        if inspect.iscoroutine(awaitable_or_fn):
-            coro = awaitable_or_fn
-        elif inspect.iscoroutinefunction(awaitable_or_fn):
-            coro = awaitable_or_fn(*args, **kwargs)
-        else:
-            raise TypeError(
-                "call_async_from_sync expects a coroutine or async function"
-            )
-
-        loop = self._ensure_loop()
-        fut = asyncio.run_coroutine_threadsafe(coro, loop)
-        return fut.result(timeout)
-
-    async def call_sync_from_async(self, fn: Callable[..., Any], *args, **kwargs):
-        """
-        Await running a blocking function in the default threadpool from async code.
-        """
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(None, lambda: fn(*args, **kwargs))
-
-    # ---------- optional cleanup ----------
-
-    def sync_close(self):
-        # Best-effort: try async close if parent provides it
-        aclose = self.close
-        if inspect.iscoroutinefunction(aclose):
-            try:
-                self.call_async_from_sync(aclose, timeout=10.0)
-            except Exception:
-                pass
-        self._shutdown_loop()
-
-    def __del__(self):
-        try:
-            self.sync_close()
-        except Exception:
-            pass

openhands/sdk/mcp/definition.py

@@ -1,69 +0,0 @@
-"""MCPTool definition and implementation."""
-
-import mcp.types
-from pydantic import Field
-
-from openhands.sdk.llm import ImageContent, TextContent
-from openhands.sdk.logger import get_logger
-from openhands.sdk.tool import (
-    ObservationBase,
-)
-
-
-logger = get_logger(__name__)
-
-
-# NOTE: We don't define MCPToolAction because it
-# will be dynamically created from the MCP tool schema.
-
-
-class MCPToolObservation(ObservationBase):
-    """Observation from MCP tool execution."""
-
-    content: list[TextContent | ImageContent] = Field(
-        default_factory=list,
-        description="Content returned from the MCP tool converted "
-        "to LLM Ready TextContent or ImageContent",
-    )
-    is_error: bool = Field(
-        default=False, description="Whether the call resulted in an error"
-    )
-    tool_name: str = Field(description="Name of the tool that was called")
-
-    @classmethod
-    def from_call_tool_result(
-        cls, tool_name: str, result: mcp.types.CallToolResult
-    ) -> "MCPToolObservation":
-        """Create an MCPToolObservation from a CallToolResult."""
-        content: list[mcp.types.ContentBlock] = result.content
-        convrted_content = []
-        for block in content:
-            if isinstance(block, mcp.types.TextContent):
-                convrted_content.append(TextContent(text=block.text))
-            elif isinstance(block, mcp.types.ImageContent):
-                convrted_content.append(
-                    ImageContent(
-                        image_urls=[f"data:{block.mimeType};base64,{block.data}"],
-                        # ImageContent is inherited from mcp.types.ImageContent
-                        # so we need to pass these fields
-                        data=block.data,
-                        mimeType=block.mimeType,
-                    )
-                )
-            else:
-                logger.warning(
-                    f"Unsupported MCP content block type: {type(block)}. Ignoring."
-                )
-        return cls(
-            content=convrted_content,
-            is_error=result.isError,
-            tool_name=tool_name,
-        )
-
-    @property
-    def agent_observation(self) -> list[TextContent | ImageContent]:
-        """Format the observation for agent display."""
-        initial_message = f"[Tool '{self.tool_name}' executed.]\n"
-        if self.is_error:
-            initial_message += "[An error occurred during execution.]\n"
-        return [TextContent(text=initial_message)] + self.content