agentengine-sdk-python 0.6.2__py3-none-any.whl → 0.6.9__py3-none-any.whl

ksadk/toolsets/_langchain.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+
+
+def as_tool(func: Callable):
+    try:
+        from langchain_core.tools import tool
+    except Exception:
+        return func
+    return tool(func)

ksadk/toolsets/platform.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import os
+
+from ksadk.skills.service_env import public_skill_space_ids, skill_space_ids, user_skill_space_ids
+from ksadk.toolsets._langchain import as_tool
+from ksadk.toolsets.sandbox import sandbox_backend_name
+from ksadk.toolsets.workspace import workspace_root
+
+
+def _env(name: str, default: str = "") -> str:
+    return str(os.environ.get(name) or default).strip()
+
+
+def _skill_execution_backend() -> str:
+    explicit = _env("KSADK_SKILL_RUNTIME_BACKEND").lower()
+    if explicit:
+        return explicit
+    if _env("KSADK_SANDBOX_TEMPLATE_ID") or _env("KSADK_SKILL_RUNTIME_TEMPLATE_ID"):
+        return "e2b"
+    return "disabled"
+
+
+def component_status() -> dict:
+    """Report AgentEngine built-in toolset and runtime binding status."""
+
+    skill_runtime_backend = _skill_execution_backend()
+    sandbox_backend = sandbox_backend_name()
+    spaces = skill_space_ids()
+    return {
+        "ok": True,
+        "summary": {
+            "model": _env("OPENAI_MODEL_NAME") or _env("MODEL_NAME"),
+            "knowledge_base_bound": bool(_env("KSADK_KB_DATASET_ID")),
+            "long_term_memory_bound": bool(_env("KSADK_LTM_NAMESPACE")),
+            "skill_space_bound": bool(spaces),
+            "isolated_execution": "enabled" if skill_runtime_backend not in {"", "disabled", "none", "off"} else "not_enabled",
+            "sandbox_direct_tools": "enabled" if sandbox_backend not in {"", "disabled", "none", "off"} else "not_enabled",
+        },
+        "skill_space": {
+            "space_ids": spaces,
+            "user_space_ids": user_skill_space_ids(),
+            "public_space_ids": public_skill_space_ids(),
+            "service_url": _env("KSADK_SKILL_SERVICE_URL"),
+            "aicp_endpoint_mode": _env("KSADK_AICP_ENDPOINT_MODE", "auto"),
+            "tools": ["list_skills", "search_skills", "load_skill", "execute_skills"],
+        },
+        "skill_runtime": {
+            "backend": skill_runtime_backend,
+            "enabled": skill_runtime_backend not in {"", "disabled", "none", "off"},
+            "template_bound": bool(_env("KSADK_SANDBOX_TEMPLATE_ID") or _env("KSADK_SKILL_RUNTIME_TEMPLATE_ID")),
+            "request_protocol": "--request-file JSON envelope",
+        },
+        "sandbox": {
+            "backend": sandbox_backend,
+            "enabled": sandbox_backend not in {"", "disabled", "none", "off"},
+            "template_bound": bool(_env("KSADK_SANDBOX_TEMPLATE_ID") or _env("KSADK_SKILL_RUNTIME_TEMPLATE_ID")),
+            "tools": ["sandbox_status", "run_command", "run_code"],
+        },
+        "workspace": {
+            "root": str(workspace_root()),
+            "tools": [
+                "workspace_status",
+                "list_workspace_files",
+                "read_workspace_file",
+                "write_workspace_file",
+                "write_workspace_files",
+                "edit_workspace_file",
+                "lint_workspace_file",
+                "search_workspace_files",
+                "delete_workspace_file",
+            ],
+            "boundary": "Workspace tools are confined to the AgentEngine UI workspace directory.",
+            "editing_model": "write tools support whole-file writes; edit_workspace_file supports exact snippet replacement; lint_workspace_file provides lightweight built-in checks.",
+        },
+    }
+
+
+def get_platform_tools() -> list:
+    tools = [as_tool(component_status)]
+    try:
+        from ksadk.knowledge_base.langchain_tool import search_knowledge_base
+
+        tools.append(search_knowledge_base)
+    except Exception:
+        pass
+    try:
+        from ksadk.memory.langchain_tool import load_memory, save_memory
+
+        tools.extend([load_memory, save_memory])
+    except Exception:
+        pass
+    return tools

ksadk/toolsets/sandbox.py

@@ -0,0 +1,310 @@
+from __future__ import annotations
+
+import os
+import shlex
+import time
+import logging
+from typing import Any
+from uuid import uuid4
+
+from ksadk.runtime_context import get_current_tool_execution_context_or_default
+from ksadk.sandbox import SandboxError, SandboxInputFile, create_sandbox_backend
+from ksadk.sandbox.registry import GLOBAL_SANDBOX_REGISTRY
+from ksadk.tools.gateway import ToolPolicy, check_command_policy, default_tool_gateway
+from ksadk.tools.result_budget import budget_text_fields
+from ksadk.toolsets._langchain import as_tool
+from ksadk.toolsets.workspace import workspace_root
+
+
+logger = logging.getLogger(__name__)
+
+
+_SANDBOX_TOOL_POLICIES = {
+    "sandbox_status": ToolPolicy(risk_level="low"),
+    "run_command": ToolPolicy(risk_level="high", side_effects=("sandbox_command_execution",)),
+    "run_code": ToolPolicy(risk_level="high", side_effects=("sandbox_code_execution",)),
+}
+
+
+def _gateway():
+    return default_tool_gateway(_SANDBOX_TOOL_POLICIES)
+
+
+def sandbox_backend_name() -> str:
+    explicit = os.environ.get("KSADK_SANDBOX_BACKEND", "").strip().lower()
+    if explicit:
+        return explicit
+    if os.environ.get("KSADK_SANDBOX_TEMPLATE_ID") or os.environ.get("KSADK_SKILL_RUNTIME_TEMPLATE_ID"):
+        return "e2b"
+    return "none"
+
+
+def _sandbox_execution_backend_name() -> str:
+    explicit = os.environ.get("KSADK_SANDBOX_BACKEND", "").strip().lower()
+    return explicit or "e2b"
+
+
+def sandbox_status() -> dict:
+    """Report configured AgentEngine sandbox status and boundaries."""
+
+    return _gateway().invoke("sandbox_status", _sandbox_status_impl)
+
+
+def _sandbox_status_impl() -> dict[str, Any]:
+    backend = sandbox_backend_name()
+    timeout = int(os.environ.get("KSADK_SANDBOX_TIMEOUT") or os.environ.get("KSADK_SKILL_RUNTIME_TIMEOUT") or "600")
+    idle_ttl = _int_env("KSADK_SANDBOX_IDLE_TTL_SECONDS", 300)
+    max_sessions = _int_env("KSADK_SANDBOX_MAX_SESSIONS", 0)
+    template_id = os.environ.get("KSADK_SANDBOX_TEMPLATE_ID") or os.environ.get("KSADK_SKILL_RUNTIME_TEMPLATE_ID") or ""
+    isolated = backend not in {"local", "local_process", "pod", "pod_process"}
+    latest = GLOBAL_SANDBOX_REGISTRY.latest()
+    now = time.time()
+    return {
+        "ok": True,
+        "backend": backend,
+        "enabled": backend not in {"", "disabled", "none", "off"},
+        "isolated": isolated,
+        "template_bound": bool(template_id),
+        "template_id": template_id,
+        "timeout_seconds": timeout,
+        "ttl_seconds": _sandbox_ttl_seconds(),
+        "idle_ttl_seconds": idle_ttl,
+        "max_sessions": max_sessions,
+        "sandbox_id": latest.sandbox_id if latest else "",
+        "created_at": latest.created_at if latest else None,
+        "last_used_at": latest.last_used_at if latest else None,
+        "expires_at": latest.expires_at if latest else None,
+        "idle_seconds": int(now - latest.last_used_at) if latest else None,
+        "boundary": _sandbox_boundary(backend),
+    }
+
+
+def run_command(
+    command: str,
+    cwd: str | None = None,
+    timeout: int | None = None,
+    env: dict[str, str] | None = None,
+    background: bool = False,
+    approval: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Run a shell command inside the configured isolated sandbox."""
+
+    return _gateway().invoke("run_command", _run_command_impl, command, cwd, timeout, env, background, approval=approval)
+
+
+def _run_command_impl(
+    command: str,
+    cwd: str | None = None,
+    timeout: int | None = None,
+    env: dict[str, str] | None = None,
+    background: bool = False,
+) -> dict[str, Any]:
+    command_text = str(command or "").strip()
+    if not command_text:
+        return {"ok": False, "error_message": "command is required"}
+    policy = check_command_policy(command_text)
+    if not policy.get("ok"):
+        return policy
+    if background:
+        return {"ok": False, "error_type": "background_not_supported", "error_message": "background commands are not supported in P0"}
+    try:
+        entry, _created = _sandbox_entry("ksadk-direct")
+        result = entry.session.run_command(command_text, timeout=timeout, env=env, cwd=cwd)
+        payload = {
+            "ok": True,
+            "backend": f"sandbox/{_sandbox_execution_backend_name()}",
+            "sandbox_id": entry.sandbox_id,
+            "command": command_text,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "exit_code": result.exit_code,
+        }
+        return budget_text_fields(payload, tool_name="run_command", fields=("stdout", "stderr"), metadata={"tool_use_id": entry.sandbox_id})
+    except SandboxError as exc:
+        return {"ok": False, "error_type": type(exc).__name__, "error_message": str(exc)}
+    except Exception as exc:
+        return {"ok": False, "error_type": type(exc).__name__, "error_message": str(exc)}
+
+
+def run_code(
+    code: str,
+    language: str = "python",
+    timeout: int | None = None,
+    env: dict[str, str] | None = None,
+    approval: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Run a code snippet through the sandbox; this is not a shell replacement."""
+
+    return _gateway().invoke("run_code", _run_code_impl, code, language, timeout, env, approval=approval)
+
+
+def _run_code_impl(
+    code: str,
+    language: str = "python",
+    timeout: int | None = None,
+    env: dict[str, str] | None = None,
+) -> dict[str, Any]:
+    source = str(code or "")
+    if not source:
+        return {"ok": False, "error_message": "code is required"}
+    backend_name = _sandbox_execution_backend_name()
+    if not _sandbox_backend_isolated(backend_name):
+        return {
+            "ok": False,
+            "error_type": "isolated_sandbox_required",
+            "error_message": "run_code requires an isolated sandbox backend; local_process and pod_process are not supported for snippet execution",
+            "backend": backend_name,
+            "boundary": _sandbox_boundary(backend_name),
+        }
+    language_name = _normalize_language(language)
+    try:
+        suffix, command_prefix = _language_command(language_name)
+    except ValueError as exc:
+        return {"ok": False, "error_message": str(exc)}
+
+    path = f"/tmp/ksadk-run-code-{uuid4().hex}{suffix}"
+    try:
+        entry, _created = _sandbox_entry("ksadk-code")
+        entry.session.write_file(path, source)
+        command = f"{command_prefix} {shlex.quote(path)}"
+        result = entry.session.run_command(command, timeout=timeout, env=env)
+        payload = {
+            "ok": True,
+            "backend": f"sandbox/{_sandbox_execution_backend_name()}",
+            "sandbox_id": entry.sandbox_id,
+            "execution_model": "snippet_runner",
+            "boundary": _sandbox_boundary(_sandbox_execution_backend_name()),
+            "language": language_name,
+            "path": path,
+            "command": command,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "exit_code": result.exit_code,
+        }
+        return budget_text_fields(payload, tool_name="run_code", fields=("stdout", "stderr"), metadata={"tool_use_id": entry.sandbox_id})
+    except SandboxError as exc:
+        return {"ok": False, "error_type": type(exc).__name__, "error_message": str(exc)}
+    except Exception as exc:
+        return {"ok": False, "error_type": type(exc).__name__, "error_message": str(exc)}
+
+
+def _normalize_language(language: str) -> str:
+    value = str(language or "python").strip().lower()
+    aliases = {
+        "py": "python",
+        "python3": "python",
+        "js": "javascript",
+        "node": "javascript",
+        "nodejs": "javascript",
+        "sh": "bash",
+        "shell": "bash",
+    }
+    return aliases.get(value, value)
+
+
+def _language_command(language: str) -> tuple[str, str]:
+    if language == "python":
+        return ".py", "python"
+    if language == "javascript":
+        return ".js", "node"
+    if language == "bash":
+        return ".sh", "bash"
+    raise ValueError(f"unsupported language: {language}")
+
+
+def _sandbox_entry(prefix: str):
+    backend_name = _sandbox_execution_backend_name()
+    backend = create_sandbox_backend()
+    ttl = _sandbox_ttl_seconds()
+    idle_ttl = _int_env("KSADK_SANDBOX_IDLE_TTL_SECONDS", 300)
+    max_sessions = _int_env("KSADK_SANDBOX_MAX_SESSIONS", 0) or None
+    key = _sandbox_session_key(prefix)
+    isolated = _sandbox_backend_isolated(backend_name)
+    input_files = _workspace_input_files() if isolated else []
+    entry, created = GLOBAL_SANDBOX_REGISTRY.get_or_create(
+        key=key,
+        backend_name=backend_name,
+        backend=backend,
+        ttl_seconds=ttl,
+        idle_ttl_seconds=idle_ttl,
+        max_sessions=max_sessions,
+        input_files=input_files,
+        isolated=isolated,
+    )
+    logger.info(
+        "ksadk.sandbox.%s",
+        "create" if created else "reuse",
+        extra={
+            "sandbox_backend": backend_name,
+            "sandbox_id": entry.sandbox_id,
+            "isolated": isolated,
+            "workspace_input_files": len(input_files) if created else 0,
+        },
+    )
+    return entry, created
+
+
+def _sandbox_session_key(prefix: str) -> str:
+    explicit = os.environ.get("KSADK_SANDBOX_SESSION_ID")
+    if explicit:
+        return explicit
+    context = get_current_tool_execution_context_or_default()
+    if context.session_id:
+        return f"ksadk-session:{context.session_id}"
+    return f"{prefix}-shared"
+
+
+def _sandbox_backend_isolated(backend_name: str) -> bool:
+    return backend_name not in {"local", "local_process", "pod", "pod_process"}
+
+
+def _workspace_input_files() -> list[SandboxInputFile]:
+    root = workspace_root()
+    if not root.exists():
+        return []
+    max_files = _int_env("KSADK_SANDBOX_SYNC_MAX_FILES", 2000)
+    max_file_bytes = _int_env("KSADK_SANDBOX_SYNC_MAX_FILE_BYTES", 2 * 1024 * 1024)
+    max_total_bytes = _int_env("KSADK_SANDBOX_SYNC_MAX_TOTAL_BYTES", 25 * 1024 * 1024)
+    skipped_dirs = {".git", "__pycache__", ".venv", "node_modules", ".pytest_cache"}
+    files: list[SandboxInputFile] = []
+    total_bytes = 0
+    for item in sorted(root.rglob("*")):
+        if len(files) >= max_files:
+            break
+        if any(part in skipped_dirs for part in item.relative_to(root).parts):
+            continue
+        if not item.is_file():
+            continue
+        size = item.stat().st_size
+        if size > max_file_bytes or total_bytes + size > max_total_bytes:
+            continue
+        relative = item.relative_to(root).as_posix()
+        files.append(SandboxInputFile(source=item, target_path=f"/workspace/{relative}"))
+        total_bytes += size
+    return files
+
+
+def _sandbox_ttl_seconds() -> int:
+    return _int_env("KSADK_SANDBOX_TTL_SECONDS", _int_env("KSADK_SANDBOX_TIMEOUT", 600))
+
+
+def _int_env(name: str, default: int) -> int:
+    raw = os.environ.get(name)
+    if raw is None:
+        return int(default)
+    try:
+        return max(0, int(raw))
+    except ValueError:
+        return int(default)
+
+
+def _sandbox_boundary(backend: str) -> str:
+    if backend in {"local", "local_process"}:
+        return "executes as a local child process; shares local filesystem, env allowlist, and network"
+    if backend in {"pod", "pod_process"}:
+        return "executes inside the agent pod; shares pod filesystem, env allowlist, network, and service account"
+    return "Sandbox tools execute commands and code only through the configured isolated sandbox backend; they never expose the host shell."
+
+
+def get_sandbox_tools() -> list:
+    return [as_tool(sandbox_status), as_tool(run_command), as_tool(run_code)]

ksadk/toolsets/skills.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import os
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from ksadk.skills.loader import load_local_skill
+from ksadk.skills.package_store import PackageStore, SkillPackageError
+from ksadk.skills.runtime import loader as runtime_loader
+from ksadk.skills.runtime.base import SkillRuntimeError
+from ksadk.skills.runtime.factory import create_skill_runtime_backend
+from ksadk.skills.runtime.registry import match_skill_refs, select_public_skill_refs
+from ksadk.skills.service_client import SkillServiceClient
+from ksadk.skills.service_env import (
+    public_skill_space_ids,
+    resolve_skill_service_url,
+    user_skill_space_ids,
+)
+from ksadk.skills.tool_defs import (
+    build_execute_skills_tool as build_runtime_execute_skills_tool,
+    load_remote_skill_manifests,
+    resolve_skill_space_ids,
+)
+from ksadk.tools.gateway import ToolPolicy, default_tool_gateway
+from ksadk.toolsets._langchain import as_tool
+
+
+_SKILL_TOOL_POLICIES = {
+    "list_skills": ToolPolicy(risk_level="low"),
+    "search_skills": ToolPolicy(risk_level="low"),
+    "load_skill": ToolPolicy(risk_level="low", side_effects=("skill_cache_write",)),
+    "execute_skills": ToolPolicy(risk_level="high", side_effects=("isolated_runtime_execution",)),
+}
+
+
+def _gateway():
+    return default_tool_gateway(_SKILL_TOOL_POLICIES)
+
+
+def list_skills() -> dict[str, Any]:
+    """List skills discoverable from configured Skill Spaces."""
+
+    try:
+        manifests = load_remote_skill_manifests(resolve_skill_space_ids())
+        return {
+            "ok": True,
+            "skills": manifests,
+            "skill_space_ids": resolve_skill_space_ids(),
+        }
+    except Exception as exc:
+        return {
+            "ok": False,
+            "error_type": type(exc).__name__,
+            "error_message": str(exc),
+            "skill_space_ids": resolve_skill_space_ids(),
+        }
+
+
+def load_skill(skill_name: str) -> dict[str, Any]:
+    """Download and load a skill's SKILL.md instructions from configured Skill Spaces."""
+
+    target = str(skill_name or "").strip().lower()
+    if not target:
+        return {"ok": False, "error_message": "skill_name is required"}
+    try:
+        client = _skill_service_client()
+        available: list[str] = []
+        for space_id, skill in _iter_remote_skills(client):
+            if not skill.name:
+                continue
+            available.append(skill.name)
+            if skill.name.strip().lower() != target:
+                continue
+            package = _get_or_download_package(client, skill)
+            local_skill = load_local_skill(package.root_dir)
+            return {
+                "ok": True,
+                "execution_context": "outer_agent",
+                "name": local_skill.name,
+                "description": local_skill.description,
+                "space_id": space_id,
+                "skill_id": skill.skill_id,
+                "version_id": skill.version_id,
+                "version": skill.version,
+                "cache_hit": bool(getattr(package, "cache_hit", False)),
+                "root_dir": str(local_skill.root_dir),
+                "has_scripts_dir": (local_skill.root_dir / "scripts").is_dir(),
+                "script_files": _script_files(local_skill.root_dir),
+                "instructions": local_skill.body,
+                "usage": "Read these instructions and complete the user's task in the outer agent unless the skill explicitly requires isolated execution.",
+            }
+        return {
+            "ok": False,
+            "error_message": f"Skill not found: {skill_name}",
+            "available_skills": available,
+        }
+    except Exception as exc:
+        return {"ok": False, "error_type": type(exc).__name__, "error_message": str(exc)}
+
+
+def search_skills(query: str, max_results: int = 10) -> dict[str, Any]:
+    """Search skills by name, aliases, tags, description, and examples."""
+
+    query_text = str(query or "").strip()
+    if not query_text:
+        return {"ok": False, "error_message": "query is required"}
+    try:
+        client = _skill_service_client()
+        refs = [skill for _, skill in _iter_remote_skills(client)]
+        matches = match_skill_refs(refs, query_text, limit=max_results)
+        return {
+            "ok": True,
+            "query": query,
+            "results": [match.to_dict() for match in matches],
+        }
+    except Exception as exc:
+        return {"ok": False, "error_type": type(exc).__name__, "error_message": str(exc)}
+
+
+def execute_skills(
+    workflow_prompt: str,
+    skill_names: list[str] | str | None = None,
+    approval: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Execute a workflow through the configured Skill Runtime."""
+
+    return _gateway().invoke(
+        "execute_skills",
+        _execute_skills_impl,
+        workflow_prompt,
+        skill_names,
+        approval=approval,
+    )
+
+
+def _execute_skills_impl(workflow_prompt: str, skill_names: list[str] | str | None = None) -> dict[str, Any]:
+    try:
+        backend = create_skill_runtime_backend()
+        raw_tool = build_runtime_execute_skills_tool(backend=backend)
+        result = raw_tool(workflow_prompt, skill_names)
+        if isinstance(result, dict):
+            result.setdefault("execution_context", f"skill-runtime/{_skill_execution_backend()}")
+        return result
+    except SkillRuntimeError as exc:
+        return {
+            "ok": False,
+            "error_type": "skill_runtime_disabled",
+            "error_message": str(exc),
+            "hint": "Configure KSADK_SKILL_RUNTIME_BACKEND=local_process/e2b or KSADK_SANDBOX_TEMPLATE_ID for isolated Skill workflow execution.",
+        }
+    except Exception as exc:
+        return {"ok": False, "error_type": type(exc).__name__, "error_message": str(exc)}
+
+
+def get_skill_tools() -> list:
+    return [as_tool(list_skills), as_tool(search_skills), as_tool(load_skill), as_tool(execute_skills)]
+
+
+def _skill_execution_backend() -> str:
+    explicit = os.environ.get("KSADK_SKILL_RUNTIME_BACKEND", "").strip().lower()
+    if explicit:
+        return explicit
+    if os.environ.get("KSADK_SANDBOX_TEMPLATE_ID") or os.environ.get("KSADK_SKILL_RUNTIME_TEMPLATE_ID"):
+        return "e2b"
+    return "disabled"
+
+
+def _skill_service_client() -> SkillServiceClient:
+    service_url = resolve_skill_service_url(require_spaces=True)
+    if not service_url:
+        raise ValueError("Skill Service URL is not configured")
+    return SkillServiceClient(
+        base_url=service_url,
+        token=os.environ.get("KSADK_SKILL_SERVICE_TOKEN", ""),
+        timeout=float(os.environ.get("KSADK_SKILL_MANIFEST_TIMEOUT", "10")),
+    )
+
+
+def _iter_remote_skills(client: SkillServiceClient):
+    for space_id in user_skill_space_ids():
+        listing = client.list_skills_by_space_id(space_id)
+        for skill in listing.active_skills():
+            yield space_id, skill
+    if public_skill_space_ids():
+        listing = client.list_available_premade_skills()
+        for skill in select_public_skill_refs(listing.active_skills()):
+            yield listing.space_id or "public", skill
+
+
+def _get_or_download_package(client: SkillServiceClient, skill):
+    cache_dir = Path(
+        os.environ.get("KSADK_SKILL_CACHE_DIR")
+        or Path(tempfile.gettempdir()) / "ksadk-skill-cache"
+    )
+    store = PackageStore(cache_dir=cache_dir)
+    package = store.get_cached(skill)
+    if package is not None:
+        return package
+    archive = client.download_skill_archive(skill)
+    try:
+        return store.store_archive(skill, archive)
+    except SkillPackageError:
+        if not runtime_loader._allow_hash_mismatch():
+            raise
+        return runtime_loader._store_unverified_archive(store, skill, archive)
+
+
+def _script_files(root_dir: Path) -> list[str]:
+    scripts_dir = root_dir / "scripts"
+    if not scripts_dir.is_dir():
+        return []
+    return [
+        str(path.relative_to(root_dir))
+        for path in sorted(scripts_dir.rglob("*"))
+        if path.is_file()
+    ][:20]