simplify(skills): inline URL fetch into Skill, remove _url_loader.py

Per maintainer feedback:
- Remove _url_loader.py — inline fetch logic directly into Skill.from_url()
- Move imports to top of module (not inside methods)
- Use source.startswith("https://") directly in _resolve_skills()
- Remove AGENTS.md entry for deleted file

The entire URL loading feature is now ~15 lines in skill.py with no
separate module.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Davide Gallitelli

AGENTS.md

@@ -141,7 +141,6 @@ strands-agents/
 │   │   │   ├── core/                     # Base classes, actions, context
 │   │   │   └── handlers/                 # Handler implementations (e.g., LLM)
 │   │   └── skills/                       # AgentSkills.io integration (Skill, AgentSkills)
-│   │       └── _url_loader.py            # HTTPS skill fetching, GitHub URL resolution
 │   │
 │   ├── experimental/                     # Experimental features (API may change)
 │   │   ├── agent_config.py               # Experimental agent config

src/strands/vended_plugins/skills/_url_loader.py

@@ -295,16 +295,14 @@ def _resolve_skills(self, sources: list[SkillSource]) -> dict[str, Skill]:
         Returns:
             Dict mapping skill names to Skill instances.
         """
-        from ._url_loader import is_url
-
         resolved: dict[str, Skill] = {}
 
         for source in sources:
             if isinstance(source, Skill):
                 if source.name in resolved:
                     logger.warning("name=<%s> | duplicate skill name, overwriting previous skill", source.name)
                 resolved[source.name] = source
-            elif isinstance(source, str) and is_url(source):
+            elif isinstance(source, str) and source.startswith("https://"):
                 try:
                     skill = Skill.from_url(source, strict=self._strict)
                     if skill.name in resolved:

src/strands/vended_plugins/skills/agent_skills.py

@@ -1,15 +1,17 @@
 """Skill data model and loading utilities for AgentSkills.io skills.
 
 This module defines the Skill dataclass and provides classmethods for
-discovering, parsing, and loading skills from the filesystem or raw content.
-Skills are directories containing a SKILL.md file with YAML frontmatter
-metadata and markdown instructions.
+discovering, parsing, and loading skills from the filesystem, raw content,
+or HTTPS URLs. Skills are directories containing a SKILL.md file with YAML
+frontmatter metadata and markdown instructions.
 """
 
 from __future__ import annotations
 
 import logging
 import re
+import urllib.error
+import urllib.request
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
@@ -359,12 +361,20 @@ def from_url(cls, url: str, *, strict: bool = False) -> Skill:
             ValueError: If ``url`` is not an ``https://`` URL.
             RuntimeError: If the SKILL.md content cannot be fetched.
         """
-        from ._url_loader import fetch_skill_content, is_url
-
-        if not is_url(url):
+        if not url.startswith("https://"):
             raise ValueError(f"url=<{url}> | not a valid HTTPS URL")
 
-        content = fetch_skill_content(url)
+        logger.info("url=<%s> | fetching skill content", url)
+
+        try:
+            req = urllib.request.Request(url, headers={"User-Agent": "strands-agents-sdk"})  # noqa: S310
+            with urllib.request.urlopen(req, timeout=30) as response:  # noqa: S310
+                content: str = response.read().decode("utf-8")
+        except urllib.error.HTTPError as e:
+            raise RuntimeError(f"url=<{url}> | HTTP {e.code}: {e.reason}") from e
+        except urllib.error.URLError as e:
+            raise RuntimeError(f"url=<{url}> | failed to fetch skill: {e.reason}") from e
+
         return cls.from_content(content, strict=strict)
 
     @classmethod

src/strands/vended_plugins/skills/skill.py

@@ -664,15 +664,25 @@ def test_resolve_nonexistent_path(self, tmp_path):
 class TestResolveUrlSkills:
     """Tests for _resolve_skills with URL sources."""
 
-    _URL_LOADER = "strands.vended_plugins.skills._url_loader"
+    _SKILL_MODULE = "strands.vended_plugins.skills.skill"
     _SAMPLE_CONTENT = "---\nname: url-skill\ndescription: A URL skill\n---\n# Instructions\n"
 
+    def _mock_urlopen(self, content):
+        """Create a mock urlopen context manager returning the given content."""
+        mock_response = MagicMock()
+        mock_response.read.return_value = content.encode("utf-8")
+        mock_response.__enter__ = MagicMock(return_value=mock_response)
+        mock_response.__exit__ = MagicMock(return_value=False)
+        return mock_response
+
     def test_resolve_url_source(self):
         """Test resolving a URL string as a skill source."""
         from unittest.mock import patch
 
-        with patch(f"{self._URL_LOADER}.fetch_skill_content", return_value=self._SAMPLE_CONTENT):
-            plugin = AgentSkills(skills=["https://github.com/org/url-skill"])
+        with patch(
+            f"{self._SKILL_MODULE}.urllib.request.urlopen", return_value=self._mock_urlopen(self._SAMPLE_CONTENT)
+        ):
+            plugin = AgentSkills(skills=["https://example.com/SKILL.md"])
 
         assert len(plugin.get_available_skills()) == 1
         assert plugin.get_available_skills()[0].name == "url-skill"
@@ -683,10 +693,12 @@ def test_resolve_mixed_url_and_local(self, tmp_path):
 
         _make_skill_dir(tmp_path, "local-skill")
 
-        with patch(f"{self._URL_LOADER}.fetch_skill_content", return_value=self._SAMPLE_CONTENT):
+        with patch(
+            f"{self._SKILL_MODULE}.urllib.request.urlopen", return_value=self._mock_urlopen(self._SAMPLE_CONTENT)
+        ):
             plugin = AgentSkills(
                 skills=[
-                    "https://github.com/org/url-skill",
+                    "https://example.com/SKILL.md",
                     str(tmp_path / "local-skill"),
                 ]
             )
@@ -698,16 +710,19 @@ def test_resolve_mixed_url_and_local(self, tmp_path):
     def test_resolve_url_failure_skips_gracefully(self, caplog):
         """Test that a failed URL fetch is skipped with a warning."""
         import logging
+        import urllib.error
         from unittest.mock import patch
 
         with (
             patch(
-                f"{self._URL_LOADER}.fetch_skill_content",
-                side_effect=RuntimeError("HTTP 404: Not Found"),
+                f"{self._SKILL_MODULE}.urllib.request.urlopen",
+                side_effect=urllib.error.HTTPError(
+                    url="https://example.com", code=404, msg="Not Found", hdrs=None, fp=None
+                ),
             ),
             caplog.at_level(logging.WARNING),
         ):
-            plugin = AgentSkills(skills=["https://github.com/org/broken"])
+            plugin = AgentSkills(skills=["https://example.com/broken/SKILL.md"])
 
         assert len(plugin.get_available_skills()) == 0
         assert "failed to load skill from URL" in caplog.text

tests/strands/vended_plugins/skills/test_agent_skills.py

@@ -554,15 +554,25 @@ def test_strict_mode(self):
 class TestSkillFromUrl:
     """Tests for Skill.from_url."""
 
-    _URL_LOADER = "strands.vended_plugins.skills._url_loader"
-
+    _SKILL_MODULE = "strands.vended_plugins.skills.skill"
     _SAMPLE_CONTENT = "---\nname: my-skill\ndescription: A remote skill\n---\nRemote instructions.\n"
 
+    def _mock_urlopen(self, content):
+        """Create a mock urlopen context manager returning the given content."""
+        from unittest.mock import MagicMock
+
+        mock_response = MagicMock()
+        mock_response.read.return_value = content.encode("utf-8")
+        mock_response.__enter__ = MagicMock(return_value=mock_response)
+        mock_response.__exit__ = MagicMock(return_value=False)
+        return mock_response
+
     def test_from_url_returns_skill(self):
         """Test loading a skill from a URL returns a single Skill."""
         from unittest.mock import patch
 
-        with patch(f"{self._URL_LOADER}.fetch_skill_content", return_value=self._SAMPLE_CONTENT):
+        mock_response = self._mock_urlopen(self._SAMPLE_CONTENT)
+        with patch(f"{self._SKILL_MODULE}.urllib.request.urlopen", return_value=mock_response):
             skill = Skill.from_url("https://raw.githubusercontent.com/org/repo/main/SKILL.md")
 
         assert isinstance(skill, Skill)
@@ -581,24 +591,39 @@ def test_from_url_http_rejected(self):
         with pytest.raises(ValueError, match="not a valid HTTPS URL"):
             Skill.from_url("http://example.com/SKILL.md")
 
-    def test_from_url_fetch_failure_raises(self):
-        """Test that a fetch failure propagates as RuntimeError."""
+    def test_from_url_http_error_raises(self):
+        """Test that HTTP errors propagate as RuntimeError."""
+        import urllib.error
         from unittest.mock import patch
 
         with patch(
-            f"{self._URL_LOADER}.fetch_skill_content",
-            side_effect=RuntimeError("HTTP 404: Not Found"),
+            f"{self._SKILL_MODULE}.urllib.request.urlopen",
+            side_effect=urllib.error.HTTPError(
+                url="https://example.com", code=404, msg="Not Found", hdrs=None, fp=None
+            ),
         ):
             with pytest.raises(RuntimeError, match="HTTP 404"):
-                Skill.from_url("https://example.com/nonexistent/SKILL.md")
+                Skill.from_url("https://example.com/SKILL.md")
+
+    def test_from_url_network_error_raises(self):
+        """Test that network errors propagate as RuntimeError."""
+        import urllib.error
+        from unittest.mock import patch
+
+        with patch(
+            f"{self._SKILL_MODULE}.urllib.request.urlopen",
+            side_effect=urllib.error.URLError("Connection refused"),
+        ):
+            with pytest.raises(RuntimeError, match="failed to fetch"):
+                Skill.from_url("https://example.com/SKILL.md")
 
     def test_from_url_strict_mode(self):
         """Test that strict mode is forwarded to from_content."""
         from unittest.mock import patch
 
         bad_content = "---\nname: BAD_NAME\ndescription: Bad\n---\nBody."
 
-        with patch(f"{self._URL_LOADER}.fetch_skill_content", return_value=bad_content):
+        with patch(f"{self._SKILL_MODULE}.urllib.request.urlopen", return_value=self._mock_urlopen(bad_content)):
             with pytest.raises(ValueError):
                 Skill.from_url("https://example.com/SKILL.md", strict=True)