openhands-agent-server 1.8.1__py3-none-any.whl → 1.9.0__py3-none-any.whl

openhands/agent_server/skills_router.py

@@ -0,0 +1,181 @@
+"""Skills router for OpenHands Agent Server.
+
+This module defines the HTTP API endpoints for skill operations.
+Business logic is delegated to skills_service.py.
+"""
+
+from typing import Literal
+
+from fastapi import APIRouter
+from pydantic import BaseModel, Field
+
+from openhands.agent_server.skills_service import (
+    ExposedUrlData,
+    load_all_skills,
+    sync_public_skills,
+)
+
+
+skills_router = APIRouter(prefix="/skills", tags=["Skills"])
+
+
+class ExposedUrl(BaseModel):
+    """Represents an exposed URL from the sandbox."""
+
+    name: str
+    url: str
+    port: int
+
+
+class OrgConfig(BaseModel):
+    """Configuration for loading organization-level skills."""
+
+    repository: str = Field(description="Selected repository (e.g., 'owner/repo')")
+    provider: str = Field(
+        description="Git provider type: github, gitlab, azure, bitbucket"
+    )
+    org_repo_url: str = Field(
+        description="Pre-authenticated Git URL for the organization repository. "
+        "Contains sensitive credentials - handle with care and avoid logging."
+    )
+    org_name: str = Field(description="Organization name")
+
+
+class SandboxConfig(BaseModel):
+    """Configuration for loading sandbox-specific skills."""
+
+    exposed_urls: list[ExposedUrl] = Field(
+        default_factory=list,
+        description="List of exposed URLs from the sandbox",
+    )
+
+
+class SkillsRequest(BaseModel):
+    """Request body for loading skills."""
+
+    load_public: bool = Field(
+        default=True, description="Load public skills from OpenHands/skills repo"
+    )
+    load_user: bool = Field(
+        default=True, description="Load user skills from ~/.openhands/skills/"
+    )
+    load_project: bool = Field(
+        default=True, description="Load project skills from workspace"
+    )
+    load_org: bool = Field(default=True, description="Load organization-level skills")
+    project_dir: str | None = Field(
+        default=None, description="Workspace directory path for project skills"
+    )
+    org_config: OrgConfig | None = Field(
+        default=None, description="Organization skills configuration"
+    )
+    sandbox_config: SandboxConfig | None = Field(
+        default=None, description="Sandbox skills configuration"
+    )
+
+
+class SkillInfo(BaseModel):
+    """Skill information returned by the API."""
+
+    name: str
+    type: Literal["repo", "knowledge", "agentskills"]
+    content: str
+    triggers: list[str] = Field(default_factory=list)
+    source: str | None = None
+    description: str | None = None
+    is_agentskills_format: bool = False
+
+
+class SkillsResponse(BaseModel):
+    """Response containing all available skills."""
+
+    skills: list[SkillInfo]
+    sources: dict[str, int] = Field(
+        default_factory=dict,
+        description="Count of skills loaded from each source",
+    )
+
+
+class SyncResponse(BaseModel):
+    """Response from skill sync operation."""
+
+    status: Literal["success", "error"]
+    message: str
+
+
+@skills_router.post("", response_model=SkillsResponse)
+def get_skills(request: SkillsRequest) -> SkillsResponse:
+    """Load and merge skills from all configured sources.
+
+    Skills are loaded from multiple sources and merged with the following
+    precedence (later overrides earlier for duplicate names):
+    1. Sandbox skills (lowest) - Exposed URLs from sandbox
+    2. Public skills - From GitHub OpenHands/skills repository
+    3. User skills - From ~/.openhands/skills/
+    4. Organization skills - From {org}/.openhands or equivalent
+    5. Project skills (highest) - From {workspace}/.openhands/skills/
+
+    Args:
+        request: SkillsRequest containing configuration for which sources to load.
+
+    Returns:
+        SkillsResponse containing merged skills and source counts.
+    """
+    # Convert Pydantic models to service data types
+    sandbox_urls = None
+    if request.sandbox_config and request.sandbox_config.exposed_urls:
+        sandbox_urls = [
+            ExposedUrlData(name=url.name, url=url.url, port=url.port)
+            for url in request.sandbox_config.exposed_urls
+        ]
+
+    org_repo_url = None
+    org_name = None
+    if request.org_config:
+        org_repo_url = request.org_config.org_repo_url
+        org_name = request.org_config.org_name
+
+    # Call the service
+    result = load_all_skills(
+        load_public=request.load_public,
+        load_user=request.load_user,
+        load_project=request.load_project,
+        load_org=request.load_org,
+        project_dir=request.project_dir,
+        org_repo_url=org_repo_url,
+        org_name=org_name,
+        sandbox_exposed_urls=sandbox_urls,
+    )
+
+    # Convert Skill objects to SkillInfo for response
+    skills_info = [
+        SkillInfo(
+            name=info.name,
+            type=info.type,
+            content=info.content,
+            triggers=info.triggers,
+            source=info.source,
+            description=info.description,
+            is_agentskills_format=info.is_agentskills_format,
+        )
+        for info in (skill.to_skill_info() for skill in result.skills)
+    ]
+
+    return SkillsResponse(skills=skills_info, sources=result.sources)
+
+
+@skills_router.post("/sync", response_model=SyncResponse)
+def sync_skills() -> SyncResponse:
+    """Force refresh of public skills from GitHub repository.
+
+    This triggers a git pull on the cached skills repository to get
+    the latest skills from the OpenHands/skills repository.
+
+    Returns:
+        SyncResponse indicating success or failure.
+    """
+    success, message = sync_public_skills()
+    return SyncResponse(
+        status="success" if success else "error",
+        message=message,
+    )

openhands/agent_server/skills_service.py

@@ -0,0 +1,401 @@
+"""Skills service for OpenHands Agent Server.
+
+This module contains the business logic for skill loading and management,
+keeping the router clean and focused on HTTP concerns.
+
+Skill Sources:
+- Public skills: GitHub OpenHands/skills repository
+- User skills: ~/.openhands/skills/ and ~/.openhands/microagents/
+- Project skills: {workspace}/.openhands/skills/, .cursorrules, agents.md
+- Organization skills: {org}/.openhands or {org}/openhands-config
+- Sandbox skills: Exposed URLs from sandbox environment
+
+Precedence (later overrides earlier):
+sandbox < public < user < org < project
+"""
+
+import os
+import shutil
+import subprocess
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+from openhands.sdk.context.skills import (
+    Skill,
+    load_project_skills,
+    load_public_skills,
+    load_user_skills,
+)
+from openhands.sdk.context.skills.skill import (
+    PUBLIC_SKILLS_BRANCH,
+    PUBLIC_SKILLS_REPO,
+    load_skills_from_dir,
+)
+from openhands.sdk.context.skills.utils import (
+    get_skills_cache_dir,
+    update_skills_repository,
+)
+from openhands.sdk.logger import get_logger
+
+
+logger = get_logger(__name__)
+
+
+# Content template for sandbox work hosts skill
+WORK_HOSTS_SKILL_CONTENT = (
+    "The user has access to the following hosts for accessing "
+    "a web application, each of which has a corresponding port:\n{hosts}"
+)
+
+# Prefix for sandbox URLs that should be exposed as work_hosts skill.
+# URLs with names starting with this prefix represent web applications
+# or services running in the sandbox that the agent should be aware of.
+SANDBOX_WORKER_URL_PREFIX = "WORKER_"
+
+
+@dataclass
+class ExposedUrlData:
+    """Internal representation of an exposed URL from the sandbox."""
+
+    name: str
+    url: str
+    port: int
+
+
+@dataclass
+class SkillLoadResult:
+    """Result of loading skills from all sources."""
+
+    skills: list[Skill]
+    sources: dict[str, int]
+
+
+def load_org_skills_from_url(
+    org_repo_url: str,
+    org_name: str,
+    working_dir: str | Path | None = None,
+) -> list[Skill]:
+    """Load skills from an organization repository.
+
+    This function clones an organization-level skills repository to a temporary
+    directory, loads skills from the skills/ and microagents/ directories, and
+    then cleans up the temporary directory.
+
+    The org_repo_url should be a pre-authenticated Git URL (e.g., containing
+    credentials or tokens) as provided by the app-server.
+
+    Note:
+        This is a blocking I/O operation that may take up to 120 seconds due to
+        the git clone timeout. When called from FastAPI endpoints defined with
+        `def` (not `async def`), FastAPI automatically runs this in a thread
+        pool to avoid blocking the event loop. Do not call this function
+        directly from async code without wrapping it in asyncio.to_thread().
+
+    Args:
+        org_repo_url: Pre-authenticated Git URL for the organization repository.
+            This should be a full Git URL that includes authentication.
+        org_name: Name of the organization (used for temp directory naming).
+        working_dir: Optional working directory for git operations. If None,
+            uses a subdirectory of the system temp directory.
+
+    Returns:
+        List of Skill objects loaded from the organization repository.
+        Returns empty list if the repository doesn't exist or loading fails.
+    """
+    all_skills: list[Skill] = []
+
+    # Determine the temporary directory for cloning
+    if working_dir:
+        base_dir = Path(working_dir) if isinstance(working_dir, str) else working_dir
+        temp_dir = base_dir / f"_org_skills_{org_name}"
+    else:
+        temp_dir = Path(tempfile.gettempdir()) / f"openhands_org_skills_{org_name}"
+
+    try:
+        # Clean up any existing temp directory
+        if temp_dir.exists():
+            shutil.rmtree(temp_dir)
+
+        # Clone the organization repository (shallow clone for efficiency)
+        logger.info(f"Cloning organization skills repository for {org_name}")
+        try:
+            subprocess.run(
+                [
+                    "git",
+                    "clone",
+                    "--depth",
+                    "1",
+                    org_repo_url,
+                    str(temp_dir),
+                ],
+                check=True,
+                capture_output=True,
+                timeout=120,
+                env={**os.environ, "GIT_TERMINAL_PROMPT": "0"},
+            )
+        except subprocess.CalledProcessError:
+            # Repository doesn't exist or access denied - this is expected.
+            # Note: We intentionally don't log stderr as it may contain credentials.
+            logger.debug(
+                f"Organization repository not found or access denied for {org_name}"
+            )
+            return all_skills
+        except subprocess.TimeoutExpired:
+            logger.warning(
+                f"Git clone timed out for organization repository {org_name}"
+            )
+            return all_skills
+
+        logger.debug(f"Successfully cloned org repository to {temp_dir}")
+
+        # Load skills from skills/ directory (preferred)
+        skills_dir = temp_dir / "skills"
+        if skills_dir.exists():
+            try:
+                repo_skills, knowledge_skills, agent_skills = load_skills_from_dir(
+                    skills_dir
+                )
+                for skills_dict in [repo_skills, knowledge_skills, agent_skills]:
+                    all_skills.extend(skills_dict.values())
+                logger.debug(
+                    f"Loaded {len(all_skills)} skills from org skills/ directory"
+                )
+            except Exception as e:
+                logger.warning(f"Failed to load skills from {skills_dir}: {e}")
+
+        # Load skills from microagents/ directory (legacy support)
+        microagents_dir = temp_dir / "microagents"
+        if microagents_dir.exists():
+            seen_names = {s.name for s in all_skills}
+            try:
+                repo_skills, knowledge_skills, agent_skills = load_skills_from_dir(
+                    microagents_dir
+                )
+                for skills_dict in [repo_skills, knowledge_skills, agent_skills]:
+                    for name, skill in skills_dict.items():
+                        if name not in seen_names:
+                            all_skills.append(skill)
+                            seen_names.add(name)
+                        else:
+                            logger.debug(
+                                f"Skipping duplicate org skill '{name}' "
+                                "from microagents/"
+                            )
+            except Exception as e:
+                logger.warning(f"Failed to load skills from {microagents_dir}: {e}")
+
+        logger.info(
+            f"Loaded {len(all_skills)} organization skills for {org_name}: "
+            f"{[s.name for s in all_skills]}"
+        )
+
+    except Exception as e:
+        logger.warning(f"Failed to load organization skills for {org_name}: {e}")
+
+    finally:
+        # Clean up the temporary directory
+        if temp_dir.exists():
+            try:
+                shutil.rmtree(temp_dir)
+                logger.debug(f"Cleaned up temp directory {temp_dir}")
+            except Exception as e:
+                logger.warning(f"Failed to clean up temp directory {temp_dir}: {e}")
+
+    return all_skills
+
+
+def create_sandbox_skill(
+    exposed_urls: list[ExposedUrlData],
+) -> Skill | None:
+    """Create a skill from sandbox exposed URLs.
+
+    This function creates a skill that informs the agent about web applications
+    and services available in the sandbox environment via exposed ports/URLs.
+
+    Only URLs with names starting with SANDBOX_WORKER_URL_PREFIX are included,
+    as these represent web applications the agent should be aware of.
+
+    Args:
+        exposed_urls: List of ExposedUrlData objects containing name, url, and port.
+
+    Returns:
+        A Skill object with work_hosts content if there are matching URLs,
+        or None if no relevant URLs are provided.
+    """
+    if not exposed_urls:
+        return None
+
+    # Filter for URLs with the worker prefix
+    worker_urls = [
+        url for url in exposed_urls if url.name.startswith(SANDBOX_WORKER_URL_PREFIX)
+    ]
+
+    if not worker_urls:
+        return None
+
+    # Build the hosts content
+    hosts_lines = []
+    for url_info in worker_urls:
+        hosts_lines.append(f"* {url_info.url} (port {url_info.port})")
+
+    hosts_content = "\n".join(hosts_lines)
+    content = WORK_HOSTS_SKILL_CONTENT.format(hosts=hosts_content)
+
+    return Skill(
+        name="work_hosts",
+        content=content,
+        trigger=None,  # Always active
+        source=None,  # Programmatically generated
+    )
+
+
+def merge_skills(skill_lists: list[list[Skill]]) -> list[Skill]:
+    """Merge multiple skill lists with precedence.
+
+    Later lists override earlier lists for duplicate names.
+
+    Args:
+        skill_lists: List of skill lists to merge in order of precedence.
+
+    Returns:
+        Merged list of skills with duplicates resolved.
+    """
+    skills_by_name: dict[str, Skill] = {}
+
+    for skill_list in skill_lists:
+        for skill in skill_list:
+            if skill.name in skills_by_name:
+                logger.info(
+                    f"Overriding skill '{skill.name}' from earlier source "
+                    "with later source"
+                )
+            skills_by_name[skill.name] = skill
+
+    return list(skills_by_name.values())
+
+
+def load_all_skills(
+    load_public: bool = True,
+    load_user: bool = True,
+    load_project: bool = True,
+    load_org: bool = True,
+    project_dir: str | None = None,
+    org_repo_url: str | None = None,
+    org_name: str | None = None,
+    sandbox_exposed_urls: list[ExposedUrlData] | None = None,
+) -> SkillLoadResult:
+    """Load and merge skills from all configured sources.
+
+    Skills are loaded from multiple sources and merged with the following
+    precedence (later overrides earlier for duplicate names):
+    1. Sandbox skills (lowest) - Exposed URLs from sandbox
+    2. Public skills - From GitHub OpenHands/skills repository
+    3. User skills - From ~/.openhands/skills/
+    4. Organization skills - From {org}/.openhands or equivalent
+    5. Project skills (highest) - From {workspace}/.openhands/skills/
+
+    Args:
+        load_public: Whether to load public skills from OpenHands/skills repo.
+        load_user: Whether to load user skills from ~/.openhands/skills/.
+        load_project: Whether to load project skills from workspace.
+        load_org: Whether to load organization-level skills.
+        project_dir: Workspace directory path for project skills.
+        org_repo_url: Pre-authenticated Git URL for org skills.
+        org_name: Organization name for org skills.
+        sandbox_exposed_urls: List of exposed URLs from sandbox.
+
+    Returns:
+        SkillLoadResult containing merged skills and source counts.
+    """
+    sources: dict[str, int] = {}
+    skill_lists: list[list[Skill]] = []
+
+    # 1. Load sandbox skills (lowest precedence)
+    sandbox_skills: list[Skill] = []
+    if sandbox_exposed_urls:
+        sandbox_skill = create_sandbox_skill(sandbox_exposed_urls)
+        if sandbox_skill:
+            sandbox_skills.append(sandbox_skill)
+    sources["sandbox"] = len(sandbox_skills)
+    skill_lists.append(sandbox_skills)
+
+    # 2. Load public skills
+    public_skills: list[Skill] = []
+    if load_public:
+        try:
+            public_skills = load_public_skills()
+            logger.info(f"Loaded {len(public_skills)} public skills")
+        except Exception as e:
+            logger.warning(f"Failed to load public skills: {e}")
+    sources["public"] = len(public_skills)
+    skill_lists.append(public_skills)
+
+    # 3. Load user skills
+    user_skills: list[Skill] = []
+    if load_user:
+        try:
+            user_skills = load_user_skills()
+            logger.info(f"Loaded {len(user_skills)} user skills")
+        except Exception as e:
+            logger.warning(f"Failed to load user skills: {e}")
+    sources["user"] = len(user_skills)
+    skill_lists.append(user_skills)
+
+    # 4. Load organization skills
+    org_skills: list[Skill] = []
+    if load_org and org_repo_url and org_name:
+        try:
+            org_skills = load_org_skills_from_url(
+                org_repo_url=org_repo_url,
+                org_name=org_name,
+            )
+            logger.info(f"Loaded {len(org_skills)} organization skills")
+        except Exception as e:
+            logger.warning(f"Failed to load organization skills: {e}")
+    sources["org"] = len(org_skills)
+    skill_lists.append(org_skills)
+
+    # 5. Load project skills (highest precedence)
+    project_skills: list[Skill] = []
+    if load_project and project_dir:
+        try:
+            project_skills = load_project_skills(project_dir)
+            logger.info(f"Loaded {len(project_skills)} project skills")
+        except Exception as e:
+            logger.warning(f"Failed to load project skills: {e}")
+    sources["project"] = len(project_skills)
+    skill_lists.append(project_skills)
+
+    # Merge all skills with precedence
+    all_skills = merge_skills(skill_lists)
+
+    logger.info(
+        f"Returning {len(all_skills)} total skills: {[s.name for s in all_skills]}"
+    )
+
+    return SkillLoadResult(skills=all_skills, sources=sources)
+
+
+def sync_public_skills() -> tuple[bool, str]:
+    """Force refresh of public skills from GitHub repository.
+
+    This triggers a git pull on the cached skills repository to get
+    the latest skills from the OpenHands/skills repository.
+
+    Returns:
+        Tuple of (success: bool, message: str).
+    """
+    try:
+        cache_dir = get_skills_cache_dir()
+        result = update_skills_repository(
+            PUBLIC_SKILLS_REPO, PUBLIC_SKILLS_BRANCH, cache_dir
+        )
+
+        if result:
+            return (True, "Skills repository synced successfully")
+        else:
+            return (False, "Failed to sync skills repository")
+    except Exception as e:
+        logger.warning(f"Failed to sync skills repository: {e}")
+        return (False, f"Sync failed: {str(e)}")

openhands/agent_server/sockets.py

@@ -142,7 +142,7 @@ async def _send_event(event: Event, websocket: WebSocket):
         dumped = event.model_dump(mode="json")
         await websocket.send_json(dumped)
     except Exception:
-        logger.exception("error_sending_event:{event}", stack_info=True)
+        logger.exception("error_sending_event: %r", event, stack_info=True)
 
 
 @dataclass
@@ -160,7 +160,7 @@ async def _send_bash_event(event: BashEventBase, websocket: WebSocket):
         dumped = event.model_dump(mode="json")
         await websocket.send_json(dumped)
     except Exception:
-        logger.exception("error_sending_event:{event}", stack_info=True)
+        logger.exception("error_sending_bash_event: %r", event, stack_info=True)
 
 
 @dataclass

{openhands_agent_server-1.8.1.dist-info → openhands_agent_server-1.9.0.dist-info}/METADATA

@@ -1,7 +1,11 @@
 Metadata-Version: 2.4
 Name: openhands-agent-server
-Version: 1.8.1
+Version: 1.9.0
 Summary: OpenHands Agent Server - REST/WebSocket interface for OpenHands AI Agent
+Project-URL: Source, https://github.com/OpenHands/software-agent-sdk
+Project-URL: Homepage, https://github.com/OpenHands/software-agent-sdk
+Project-URL: Documentation, https://docs.openhands.dev/sdk
+Project-URL: Bug Tracker, https://github.com/OpenHands/software-agent-sdk/issues
 Requires-Python: >=3.12
 Requires-Dist: aiosqlite>=0.19
 Requires-Dist: alembic>=1.13

{openhands_agent_server-1.8.1.dist-info → openhands_agent_server-1.9.0.dist-info}/RECORD

@@ -1,39 +1,41 @@
 openhands/agent_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-openhands/agent_server/__main__.py,sha256=TDeBZxdloHltvdRDiFcwDZ5SW0sk3NONTDoqGt2IhsE,1619
-openhands/agent_server/api.py,sha256=M9__D_T6m3_0dlkbZzahMM_SPF-j0uYAnoJoCvkZGQM,11901
-openhands/agent_server/bash_router.py,sha256=9aKNxzdKSlKoYJ3ngvdf4rjv1_iNNmpRoZkqhJ4qhxQ,3203
+openhands/agent_server/__main__.py,sha256=QCdBRWVV9gNtPwRwYieQisvKsmJljjJ8f293RhtHl_w,3642
+openhands/agent_server/api.py,sha256=LqU4BWXc4VQ29sIiABZykznSMJ_dUQEOHixxeLBTuGY,12009
+openhands/agent_server/bash_router.py,sha256=9GRsLeVZgqR1XeayJvBBycVqfg5O-Fye2ek75kGCuno,3353
 openhands/agent_server/bash_service.py,sha256=QgTSyQoxlk52BnZuo35xlX7u7-3xs5BvvaKU3AEva_w,14083
-openhands/agent_server/config.py,sha256=EQdoN39cOeI63zEpAQ7WyhMpo-9tHNTsLMalU0d4kHw,5479
+openhands/agent_server/config.py,sha256=EKxVV0QyD3KLLtFxNuUextxJplLW_zZ32nPFhli6ozA,6403
 openhands/agent_server/conversation_router.py,sha256=lz-dnfPXrVBiGZ9GhYqfteCWJ4pq7AcnWqxsKWwCfc0,11178
 openhands/agent_server/conversation_service.py,sha256=Oj8IBSY9ZYbduOOBatd3I0H_kSyH7xi22Y_MyhfL5Tk,27058
 openhands/agent_server/dependencies.py,sha256=H3zyOc8uthpXseB3E7rWNccKIj7PlyfcgCYwFvmFq4c,2629
 openhands/agent_server/desktop_router.py,sha256=OaCmevO33eUo3jTwiXBmQ3uT3ONu4-tqgBfYpZWrHSA,1349
 openhands/agent_server/desktop_service.py,sha256=iCwQJXK4DvGuBXKOQ1oko60wXkf_pYHCubOzBsd2k60,7415
-openhands/agent_server/env_parser.py,sha256=NBa5p_JGYJVMMdCJJ_jicW1iAGS6h8AG_HVlcQ2dxaY,14929
+openhands/agent_server/env_parser.py,sha256=GDTLy9-k-GBOvpVI8VlYuqN-kLRZw6ieR2TgWFsOIms,16400
 openhands/agent_server/event_router.py,sha256=XM46zcqPOXStISfihzsPXPfsW_23E50brmBHk04ncVI,6156
-openhands/agent_server/event_service.py,sha256=N-RKeXox4dMsZv-8brwYRtt5p2axfznPfd6C-8TKXk4,25189
-openhands/agent_server/file_router.py,sha256=ysDjIKzDNbi7m95JrH6kP6BYcBhTJhTpJVMkNtYVYhs,4011
-openhands/agent_server/git_router.py,sha256=g0cVeyJ_mUAuieZ3bbTl5Xvm94FnNwRt07iNBASiXgU,844
-openhands/agent_server/logging_config.py,sha256=DPPxIl1tUVGiui-JVSKgs73KXPFfDNX2ivGuZSkbLe4,1832
-openhands/agent_server/middleware.py,sha256=9wuAurN8TCXTCRl6ANIMoFSvHeZsYDLFXIrBH15yhQU,1117
+openhands/agent_server/event_service.py,sha256=EFjIkWbTrROAv2zFzsIOhcRDTZIhf0uIGQStNDg8nFY,26838
+openhands/agent_server/file_router.py,sha256=MqFmTcDFE42EEPwRncBtT-Vu8_U78OZfC6pm0tnlBZk,4161
+openhands/agent_server/git_router.py,sha256=z-jbkY4me1HuLOWTzJu_osI19ZGGri5ffYujVAWe31s,974
+openhands/agent_server/logging_config.py,sha256=b3N5LVGuwDd0bBsMxrVdCHa8N1Nsreawgi23hTkDrro,3985
+openhands/agent_server/middleware.py,sha256=WQN5T14E58cvG2ZG6qfaJL4Dk9DqUGqD5tyAva1Un_4,1407
 openhands/agent_server/models.py,sha256=R3WSDIQN1burIyV4Dz05YITR9WWcC_pXgZDk-7WG6hw,9723
 openhands/agent_server/openapi.py,sha256=RJWaOnM9NjzrH-fJi3PoIBv5d0sH5z8zZTdvYzSqoFU,482
 openhands/agent_server/pub_sub.py,sha256=yPB84Wub7A2uwUWsW_grbxomWmKaWyGuo6dVNUzg1FU,2755
 openhands/agent_server/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 openhands/agent_server/server_details_router.py,sha256=LCa0NQ3SOw-IgJh3rDJL5GolFOpZcX_-XEbDLHF8dN4,950
-openhands/agent_server/sockets.py,sha256=pWjuRpWeqPw-T5svqb5mO7JCAVcCptQyHxc6lDYHhvY,6606
+openhands/agent_server/skills_router.py,sha256=mYiIAOGJxnpMz_OsbtP2cBjHNvo3qYUXqGPHKQs_pEw,5601
+openhands/agent_server/skills_service.py,sha256=hmyo1FtUEwfPWk1NnMyGGhvIqPwO28Mjk3chUw_98XM,14125
+openhands/agent_server/sockets.py,sha256=UhZr_QoHsIX7x_tzvk9_AJa2S8KJmRr4syhIU4He8Rs,6617
 openhands/agent_server/tool_preload_service.py,sha256=2QuFyn7jC4Ifq2aUhs9j8876wSBdY0eeoLo4qEVi-yA,2341
 openhands/agent_server/tool_router.py,sha256=vM_9UKUzfChLK9B9Z3DL4VtKNdDw4w635knu9N36y0c,676
 openhands/agent_server/utils.py,sha256=ajivE_kGCJ9qUhF9H3Qu7DUKg7uDvDQk16JcO3XntEs,1926
 openhands/agent_server/vscode_router.py,sha256=tPmXzN6teuqMa1jvKS4Q3aWpk9p9wsp4LleKoDvkYGs,2133
 openhands/agent_server/vscode_service.py,sha256=xS_vwIU5W5KwXTbOTzHPkPRIB4xbjmYlAygmRfBOAF8,7606
-openhands/agent_server/docker/Dockerfile,sha256=NuGBEpRbcFA2e8xfOhsG2iVIz5J047xJqWEAvw5X4sw,10711
-openhands/agent_server/docker/build.py,sha256=Egsge_yIVCeiJ_gvva6VyPeQtOp0WjZFsWvybFV-OfQ,27555
+openhands/agent_server/docker/Dockerfile,sha256=rdFlMdI_uITipzR7-pPEGFx2Ld-jYhOBfGKONRk4dbU,10724
+openhands/agent_server/docker/build.py,sha256=UgHoLkgHZtgWqloG2MQ2RCzc6zTIyttOFL_vUzmw_c0,28189
 openhands/agent_server/docker/wallpaper.svg,sha256=FR2g_b5mzz0x5EvRTKO93ASnWPagAyeS9RI3vRQBAsw,11532
 openhands/agent_server/vscode_extensions/openhands-settings/extension.js,sha256=xoCKZ6YXlzlTWnTC52HuzX0sn9s77Vma-47WgEibO88,858
 openhands/agent_server/vscode_extensions/openhands-settings/package.json,sha256=eCkuBBYEVArEjpp7c_m0H207OCLEygZhBLUEkeFNWOg,289
-openhands_agent_server-1.8.1.dist-info/METADATA,sha256=3uVueui8cp5vLxXTC7da-_bLIcDl9Lsd_wizydGpfbM,468
-openhands_agent_server-1.8.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-openhands_agent_server-1.8.1.dist-info/entry_points.txt,sha256=uLQzPhqDqe85Dy9DvPiBE2CeqkwCryggr1Ty_mq65NA,70
-openhands_agent_server-1.8.1.dist-info/top_level.txt,sha256=jHgVu9I0Blam8BXFgedoGKfglPF8XvW1TsJFIjcgP4E,10
-openhands_agent_server-1.8.1.dist-info/RECORD,,
+openhands_agent_server-1.9.0.dist-info/METADATA,sha256=xU9j2XKQ9PD1vPh5e7APdXkY4JzfFRlWv-BBe9ZeIEE,748
+openhands_agent_server-1.9.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+openhands_agent_server-1.9.0.dist-info/entry_points.txt,sha256=uLQzPhqDqe85Dy9DvPiBE2CeqkwCryggr1Ty_mq65NA,70
+openhands_agent_server-1.9.0.dist-info/top_level.txt,sha256=jHgVu9I0Blam8BXFgedoGKfglPF8XvW1TsJFIjcgP4E,10
+openhands_agent_server-1.9.0.dist-info/RECORD,,

{openhands_agent_server-1.8.1.dist-info → openhands_agent_server-1.9.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any