chore: initial snapshot for gitea/github upload

llm-gateway-competitors/litellm-wheel-src/litellm/skills/__init__.py

@@ -0,0 +1,23 @@
+"""Skills API integration for LiteLLM"""
+
+from .main import (
+    acreate_skill,
+    adelete_skill,
+    aget_skill,
+    alist_skills,
+    create_skill,
+    delete_skill,
+    get_skill,
+    list_skills,
+)
+
+__all__ = [
+    "create_skill",
+    "acreate_skill",
+    "list_skills",
+    "alist_skills",
+    "get_skill",
+    "aget_skill",
+    "delete_skill",
+    "adelete_skill",
+]

llm-gateway-competitors/litellm-wheel-src/litellm/skills/main.py

@@ -0,0 +1,756 @@
+"""
+Main entry point for Skills API operations
+Provides create, list, get, and delete operations for skills
+"""
+
+import asyncio
+import contextvars
+from functools import partial
+from typing import Any, Coroutine, Dict, List, Optional, Union
+
+import httpx
+
+import litellm
+from litellm.constants import request_timeout
+from litellm.litellm_core_utils.litellm_logging import Logging as LiteLLMLoggingObj
+from litellm.llms.base_llm.skills.transformation import BaseSkillsAPIConfig
+from litellm.llms.custom_httpx.llm_http_handler import BaseLLMHTTPHandler
+from litellm.types.llms.anthropic_skills import (
+    CreateSkillRequest,
+    DeleteSkillResponse,
+    ListSkillsParams,
+    ListSkillsResponse,
+    Skill,
+)
+from litellm.types.router import GenericLiteLLMParams
+from litellm.types.utils import LlmProviders
+from litellm.utils import ProviderConfigManager, client
+
+# Initialize HTTP handler
+base_llm_http_handler = BaseLLMHTTPHandler()
+DEFAULT_ANTHROPIC_API_BASE = "https://api.anthropic.com/v1"
+
+# Initialize LiteLLM skills handler (lazy - only used when custom_llm_provider="litellm")
+_litellm_skills_handler = None
+
+
+def _get_litellm_skills_handler():
+    """Lazy initialization of LiteLLM skills handler to avoid import overhead."""
+    global _litellm_skills_handler
+    if _litellm_skills_handler is None:
+        from litellm.llms.litellm_proxy.skills.transformation import (
+            LiteLLMSkillsTransformationHandler,
+        )
+
+        _litellm_skills_handler = LiteLLMSkillsTransformationHandler()
+    return _litellm_skills_handler
+
+
+@client
+async def acreate_skill(
+    files: Optional[List[Any]] = None,
+    display_title: Optional[str] = None,
+    extra_headers: Optional[Dict[str, Any]] = None,
+    extra_query: Optional[Dict[str, Any]] = None,
+    extra_body: Optional[Dict[str, Any]] = None,
+    timeout: Optional[Union[float, httpx.Timeout]] = None,
+    custom_llm_provider: Optional[str] = None,
+    **kwargs,
+) -> Skill:
+    """
+    Async: Create a new skill
+
+    Args:
+        files: Files to upload for the skill. All files must be in the same top-level directory and must include a SKILL.md file at the root.
+        display_title: Optional display title for the skill
+        extra_headers: Additional headers for the request
+        extra_query: Additional query parameters
+        extra_body: Additional body parameters
+        timeout: Request timeout
+        custom_llm_provider: Provider name (e.g., 'anthropic')
+        **kwargs: Additional parameters
+
+    Returns:
+        Skill object
+    """
+    local_vars = locals()
+    try:
+        loop = asyncio.get_event_loop()
+        kwargs["acreate_skill"] = True
+
+        func = partial(
+            create_skill,
+            files=files,
+            display_title=display_title,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            extra_body=extra_body,
+            timeout=timeout,
+            custom_llm_provider=custom_llm_provider,
+            **kwargs,
+        )
+
+        ctx = contextvars.copy_context()
+        func_with_context = partial(ctx.run, func)
+        init_response = await loop.run_in_executor(None, func_with_context)
+
+        if asyncio.iscoroutine(init_response):
+            response = await init_response
+        else:
+            response = init_response
+        return response
+    except Exception as e:
+        raise litellm.exception_type(
+            model=None,
+            custom_llm_provider=custom_llm_provider,
+            original_exception=e,
+            completion_kwargs=local_vars,
+            extra_kwargs=kwargs,
+        )
+
+
+@client
+def create_skill(
+    files: Optional[List[Any]] = None,
+    display_title: Optional[str] = None,
+    extra_headers: Optional[Dict[str, Any]] = None,
+    extra_query: Optional[Dict[str, Any]] = None,
+    extra_body: Optional[Dict[str, Any]] = None,
+    timeout: Optional[Union[float, httpx.Timeout]] = None,
+    custom_llm_provider: Optional[str] = None,
+    **kwargs,
+) -> Union[Skill, Coroutine[Any, Any, Skill]]:
+    """
+    Create a new skill
+
+    Args:
+        files: Files to upload for the skill. All files must be in the same top-level directory and must include a SKILL.md file at the root.
+        display_title: Optional display title for the skill
+        extra_headers: Additional headers for the request
+        extra_query: Additional query parameters
+        extra_body: Additional body parameters
+        timeout: Request timeout
+        custom_llm_provider: Provider name (e.g., 'anthropic')
+        **kwargs: Additional parameters
+
+    Returns:
+        Skill object
+    """
+    local_vars = locals()
+    try:
+        litellm_logging_obj: LiteLLMLoggingObj = kwargs.get("litellm_logging_obj")  # type: ignore
+        litellm_call_id: Optional[str] = kwargs.get("litellm_call_id", None)
+        _is_async = kwargs.pop("acreate_skill", False) is True
+
+        # Get LiteLLM parameters
+        litellm_params = GenericLiteLLMParams(**kwargs)
+
+        # Determine provider
+        if custom_llm_provider is None:
+            custom_llm_provider = "anthropic"
+
+        # Build create request
+        create_request: CreateSkillRequest = {}
+        if display_title is not None:
+            create_request["display_title"] = display_title
+        if files is not None:
+            create_request["files"] = files
+
+        # Merge extra_body if provided
+        if extra_body:
+            create_request.update(extra_body)  # type: ignore
+
+        # Route to LiteLLM DB if custom_llm_provider="litellm_proxy"
+        if custom_llm_provider == LlmProviders.LITELLM_PROXY.value:
+            return _get_litellm_skills_handler().create_skill_handler(
+                display_title=display_title,
+                files=files,
+                metadata=extra_body.get("metadata") if extra_body else None,
+                user_id=kwargs.get("user_id"),
+                _is_async=_is_async,
+                logging_obj=litellm_logging_obj,
+                litellm_call_id=litellm_call_id,
+            )
+
+        # Get provider config for external providers (Anthropic, etc.)
+        skills_api_provider_config: Optional[
+            BaseSkillsAPIConfig
+        ] = ProviderConfigManager.get_provider_skills_api_config(
+            provider=litellm.LlmProviders(custom_llm_provider),
+        )
+
+        if skills_api_provider_config is None:
+            raise ValueError(f"CREATE skill is not supported for {custom_llm_provider}")
+
+        # Validate environment and get headers
+        headers = extra_headers or {}
+        headers = skills_api_provider_config.validate_environment(
+            headers=headers, litellm_params=litellm_params
+        )
+
+        # Transform request
+        request_body = skills_api_provider_config.transform_create_skill_request(
+            create_request=create_request,
+            litellm_params=litellm_params,
+            headers=headers,
+        )
+
+        # Get API base and URL
+        from litellm.llms.anthropic.common_utils import AnthropicModelInfo
+
+        api_base = AnthropicModelInfo.get_api_base(litellm_params.api_base)
+        url = skills_api_provider_config.get_complete_url(
+            api_base=api_base, endpoint="skills"
+        )
+
+        # Pre-call logging
+        litellm_logging_obj.update_environment_variables(
+            model=None,
+            optional_params=request_body,
+            litellm_params={
+                "litellm_call_id": litellm_call_id,
+            },
+            custom_llm_provider=custom_llm_provider,
+        )
+
+        # Make HTTP request
+        response = base_llm_http_handler.create_skill_handler(
+            url=url,
+            request_body=request_body,
+            skills_api_provider_config=skills_api_provider_config,
+            custom_llm_provider=custom_llm_provider,
+            litellm_params=litellm_params,
+            logging_obj=litellm_logging_obj,
+            extra_headers=headers,
+            timeout=timeout or request_timeout,
+            _is_async=_is_async,
+            client=kwargs.get("client"),
+            shared_session=kwargs.get("shared_session"),
+        )
+
+        return response
+    except Exception as e:
+        raise litellm.exception_type(
+            model=None,
+            custom_llm_provider=custom_llm_provider,
+            original_exception=e,
+            completion_kwargs=local_vars,
+            extra_kwargs=kwargs,
+        )
+
+
+@client
+async def alist_skills(
+    limit: Optional[int] = None,
+    page: Optional[str] = None,
+    source: Optional[str] = None,
+    extra_headers: Optional[Dict[str, Any]] = None,
+    extra_query: Optional[Dict[str, Any]] = None,
+    timeout: Optional[Union[float, httpx.Timeout]] = None,
+    custom_llm_provider: Optional[str] = None,
+    **kwargs,
+) -> ListSkillsResponse:
+    """
+    Async: List all skills
+
+    Args:
+        limit: Number of results to return per page (max 100, default 20)
+        page: Pagination token for fetching a specific page of results
+        source: Filter skills by source ('custom' or 'anthropic')
+        extra_headers: Additional headers for the request
+        extra_query: Additional query parameters
+        timeout: Request timeout
+        custom_llm_provider: Provider name (e.g., 'anthropic')
+        **kwargs: Additional parameters
+
+    Returns:
+        ListSkillsResponse object
+    """
+    local_vars = locals()
+    try:
+        loop = asyncio.get_event_loop()
+        kwargs["alist_skills"] = True
+
+        func = partial(
+            list_skills,
+            limit=limit,
+            page=page,
+            source=source,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            timeout=timeout,
+            custom_llm_provider=custom_llm_provider,
+            **kwargs,
+        )
+
+        ctx = contextvars.copy_context()
+        func_with_context = partial(ctx.run, func)
+        init_response = await loop.run_in_executor(None, func_with_context)
+
+        if asyncio.iscoroutine(init_response):
+            response = await init_response
+        else:
+            response = init_response
+        return response
+    except Exception as e:
+        raise litellm.exception_type(
+            model=None,
+            custom_llm_provider=custom_llm_provider,
+            original_exception=e,
+            completion_kwargs=local_vars,
+            extra_kwargs=kwargs,
+        )
+
+
+@client
+def list_skills(
+    limit: Optional[int] = None,
+    page: Optional[str] = None,
+    source: Optional[str] = None,
+    extra_headers: Optional[Dict[str, Any]] = None,
+    extra_query: Optional[Dict[str, Any]] = None,
+    timeout: Optional[Union[float, httpx.Timeout]] = None,
+    custom_llm_provider: Optional[str] = None,
+    **kwargs,
+) -> Union[ListSkillsResponse, Coroutine[Any, Any, ListSkillsResponse]]:
+    """
+    List all skills
+
+    Args:
+        limit: Number of results to return per page (max 100, default 20)
+        page: Pagination token for fetching a specific page of results
+        source: Filter skills by source ('custom' or 'anthropic')
+        extra_headers: Additional headers for the request
+        extra_query: Additional query parameters
+        timeout: Request timeout
+        custom_llm_provider: Provider name (e.g., 'anthropic')
+        **kwargs: Additional parameters
+
+    Returns:
+        ListSkillsResponse object
+    """
+    local_vars = locals()
+    try:
+        litellm_logging_obj: LiteLLMLoggingObj = kwargs.get("litellm_logging_obj")  # type: ignore
+        litellm_call_id: Optional[str] = kwargs.get("litellm_call_id", None)
+        _is_async = kwargs.pop("alist_skills", False) is True
+
+        # Get LiteLLM parameters
+        litellm_params = GenericLiteLLMParams(**kwargs)
+
+        # Determine provider
+        if custom_llm_provider is None:
+            custom_llm_provider = "anthropic"
+
+        # Route to LiteLLM DB if custom_llm_provider="litellm_proxy"
+        if custom_llm_provider == LlmProviders.LITELLM_PROXY.value:
+            return _get_litellm_skills_handler().list_skills_handler(
+                limit=limit or 20,
+                offset=0,
+                _is_async=_is_async,
+                logging_obj=litellm_logging_obj,
+                litellm_call_id=litellm_call_id,
+            )
+
+        # Get provider config for external providers (Anthropic, etc.)
+        skills_api_provider_config: Optional[
+            BaseSkillsAPIConfig
+        ] = ProviderConfigManager.get_provider_skills_api_config(
+            provider=litellm.LlmProviders(custom_llm_provider),
+        )
+
+        if skills_api_provider_config is None:
+            raise ValueError(f"LIST skills is not supported for {custom_llm_provider}")
+
+        # Build list parameters
+        list_params: ListSkillsParams = {}
+        if limit is not None:
+            list_params["limit"] = limit
+        if page is not None:
+            list_params["page"] = page
+        if source is not None:
+            list_params["source"] = source
+
+        # Merge extra_query if provided
+        if extra_query:
+            list_params.update(extra_query)  # type: ignore
+
+        # Validate environment and get headers
+        headers = extra_headers or {}
+        headers = skills_api_provider_config.validate_environment(
+            headers=headers, litellm_params=litellm_params
+        )
+
+        # Transform request
+        url, query_params = skills_api_provider_config.transform_list_skills_request(
+            list_params=list_params,
+            litellm_params=litellm_params,
+            headers=headers,
+        )
+
+        # Pre-call logging
+        litellm_logging_obj.update_environment_variables(
+            model=None,
+            optional_params=query_params,
+            litellm_params={
+                "litellm_call_id": litellm_call_id,
+            },
+            custom_llm_provider=custom_llm_provider,
+        )
+
+        # Make HTTP request
+        response = base_llm_http_handler.list_skills_handler(
+            url=url,
+            query_params=query_params,
+            skills_api_provider_config=skills_api_provider_config,
+            custom_llm_provider=custom_llm_provider,
+            litellm_params=litellm_params,
+            logging_obj=litellm_logging_obj,
+            extra_headers=headers,
+            timeout=timeout or request_timeout,
+            _is_async=_is_async,
+            client=kwargs.get("client"),
+            shared_session=kwargs.get("shared_session"),
+        )
+
+        return response
+    except Exception as e:
+        raise litellm.exception_type(
+            model=None,
+            custom_llm_provider=custom_llm_provider,
+            original_exception=e,
+            completion_kwargs=local_vars,
+            extra_kwargs=kwargs,
+        )
+
+
+@client
+async def aget_skill(
+    skill_id: str,
+    extra_headers: Optional[Dict[str, Any]] = None,
+    extra_query: Optional[Dict[str, Any]] = None,
+    timeout: Optional[Union[float, httpx.Timeout]] = None,
+    custom_llm_provider: Optional[str] = None,
+    **kwargs,
+) -> Skill:
+    """
+    Async: Get a skill by ID
+
+    Args:
+        skill_id: The ID of the skill to fetch
+        extra_headers: Additional headers for the request
+        extra_query: Additional query parameters
+        timeout: Request timeout
+        custom_llm_provider: Provider name (e.g., 'anthropic')
+        **kwargs: Additional parameters
+
+    Returns:
+        Skill object
+    """
+    local_vars = locals()
+    try:
+        loop = asyncio.get_event_loop()
+        kwargs["aget_skill"] = True
+
+        func = partial(
+            get_skill,
+            skill_id=skill_id,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            timeout=timeout,
+            custom_llm_provider=custom_llm_provider,
+            **kwargs,
+        )
+
+        ctx = contextvars.copy_context()
+        func_with_context = partial(ctx.run, func)
+        init_response = await loop.run_in_executor(None, func_with_context)
+
+        if asyncio.iscoroutine(init_response):
+            response = await init_response
+        else:
+            response = init_response
+        return response
+    except Exception as e:
+        raise litellm.exception_type(
+            model=None,
+            custom_llm_provider=custom_llm_provider,
+            original_exception=e,
+            completion_kwargs=local_vars,
+            extra_kwargs=kwargs,
+        )
+
+
+@client
+def get_skill(
+    skill_id: str,
+    extra_headers: Optional[Dict[str, Any]] = None,
+    extra_query: Optional[Dict[str, Any]] = None,
+    timeout: Optional[Union[float, httpx.Timeout]] = None,
+    custom_llm_provider: Optional[str] = None,
+    **kwargs,
+) -> Union[Skill, Coroutine[Any, Any, Skill]]:
+    """
+    Get a skill by ID
+
+    Args:
+        skill_id: The ID of the skill to fetch
+        extra_headers: Additional headers for the request
+        extra_query: Additional query parameters
+        timeout: Request timeout
+        custom_llm_provider: Provider name (e.g., 'anthropic')
+        **kwargs: Additional parameters
+
+    Returns:
+        Skill object
+    """
+    local_vars = locals()
+    try:
+        litellm_logging_obj: LiteLLMLoggingObj = kwargs.get("litellm_logging_obj")  # type: ignore
+        litellm_call_id: Optional[str] = kwargs.get("litellm_call_id", None)
+        _is_async = kwargs.pop("aget_skill", False) is True
+
+        # Get LiteLLM parameters
+        litellm_params = GenericLiteLLMParams(**kwargs)
+
+        # Determine provider
+        if custom_llm_provider is None:
+            custom_llm_provider = "anthropic"
+
+        # Route to LiteLLM DB if custom_llm_provider="litellm_proxy"
+        if custom_llm_provider == LlmProviders.LITELLM_PROXY.value:
+            return _get_litellm_skills_handler().get_skill_handler(
+                skill_id=skill_id,
+                _is_async=_is_async,
+                logging_obj=litellm_logging_obj,
+                litellm_call_id=litellm_call_id,
+            )
+
+        # Get provider config for external providers (Anthropic, etc.)
+        skills_api_provider_config: Optional[
+            BaseSkillsAPIConfig
+        ] = ProviderConfigManager.get_provider_skills_api_config(
+            provider=litellm.LlmProviders(custom_llm_provider),
+        )
+
+        if skills_api_provider_config is None:
+            raise ValueError(f"GET skill is not supported for {custom_llm_provider}")
+
+        # Validate environment and get headers
+        headers = extra_headers or {}
+        headers = skills_api_provider_config.validate_environment(
+            headers=headers, litellm_params=litellm_params
+        )
+
+        # Get API base
+        from litellm.llms.anthropic.common_utils import AnthropicModelInfo
+
+        api_base = AnthropicModelInfo.get_api_base(litellm_params.api_base)
+
+        # Transform request
+        url, headers = skills_api_provider_config.transform_get_skill_request(
+            skill_id=skill_id,
+            api_base=api_base or DEFAULT_ANTHROPIC_API_BASE,
+            litellm_params=litellm_params,
+            headers=headers,
+        )
+
+        # Pre-call logging
+        litellm_logging_obj.update_environment_variables(
+            model=None,
+            optional_params={"skill_id": skill_id},
+            litellm_params={
+                "litellm_call_id": litellm_call_id,
+            },
+            custom_llm_provider=custom_llm_provider,
+        )
+
+        # Make HTTP request
+        response = base_llm_http_handler.get_skill_handler(
+            url=url,
+            skills_api_provider_config=skills_api_provider_config,
+            custom_llm_provider=custom_llm_provider,
+            litellm_params=litellm_params,
+            logging_obj=litellm_logging_obj,
+            extra_headers=headers,
+            timeout=timeout or request_timeout,
+            _is_async=_is_async,
+            client=kwargs.get("client"),
+            shared_session=kwargs.get("shared_session"),
+        )
+
+        return response
+    except Exception as e:
+        raise litellm.exception_type(
+            model=None,
+            custom_llm_provider=custom_llm_provider,
+            original_exception=e,
+            completion_kwargs=local_vars,
+            extra_kwargs=kwargs,
+        )
+
+
+@client
+async def adelete_skill(
+    skill_id: str,
+    extra_headers: Optional[Dict[str, Any]] = None,
+    extra_query: Optional[Dict[str, Any]] = None,
+    timeout: Optional[Union[float, httpx.Timeout]] = None,
+    custom_llm_provider: Optional[str] = None,
+    **kwargs,
+) -> DeleteSkillResponse:
+    """
+    Async: Delete a skill by ID
+
+    Args:
+        skill_id: The ID of the skill to delete
+        extra_headers: Additional headers for the request
+        extra_query: Additional query parameters
+        timeout: Request timeout
+        custom_llm_provider: Provider name (e.g., 'anthropic')
+        **kwargs: Additional parameters
+
+    Returns:
+        DeleteSkillResponse object
+    """
+    local_vars = locals()
+    try:
+        loop = asyncio.get_event_loop()
+        kwargs["adelete_skill"] = True
+
+        func = partial(
+            delete_skill,
+            skill_id=skill_id,
+            extra_headers=extra_headers,
+            extra_query=extra_query,
+            timeout=timeout,
+            custom_llm_provider=custom_llm_provider,
+            **kwargs,
+        )
+
+        ctx = contextvars.copy_context()
+        func_with_context = partial(ctx.run, func)
+        init_response = await loop.run_in_executor(None, func_with_context)
+
+        if asyncio.iscoroutine(init_response):
+            response = await init_response
+        else:
+            response = init_response
+        return response
+    except Exception as e:
+        raise litellm.exception_type(
+            model=None,
+            custom_llm_provider=custom_llm_provider,
+            original_exception=e,
+            completion_kwargs=local_vars,
+            extra_kwargs=kwargs,
+        )
+
+
+@client
+def delete_skill(
+    skill_id: str,
+    extra_headers: Optional[Dict[str, Any]] = None,
+    extra_query: Optional[Dict[str, Any]] = None,
+    timeout: Optional[Union[float, httpx.Timeout]] = None,
+    custom_llm_provider: Optional[str] = None,
+    **kwargs,
+) -> Union[DeleteSkillResponse, Coroutine[Any, Any, DeleteSkillResponse]]:
+    """
+    Delete a skill by ID
+
+    Args:
+        skill_id: The ID of the skill to delete
+        extra_headers: Additional headers for the request
+        extra_query: Additional query parameters
+        timeout: Request timeout
+        custom_llm_provider: Provider name (e.g., 'anthropic')
+        **kwargs: Additional parameters
+
+    Returns:
+        DeleteSkillResponse object
+    """
+    local_vars = locals()
+    try:
+        litellm_logging_obj: LiteLLMLoggingObj = kwargs.get("litellm_logging_obj")  # type: ignore
+        litellm_call_id: Optional[str] = kwargs.get("litellm_call_id", None)
+        _is_async = kwargs.pop("adelete_skill", False) is True
+
+        # Get LiteLLM parameters
+        litellm_params = GenericLiteLLMParams(**kwargs)
+
+        # Determine provider
+        if custom_llm_provider is None:
+            custom_llm_provider = "anthropic"
+
+        # Route to LiteLLM DB if custom_llm_provider="litellm_proxy"
+        if custom_llm_provider == LlmProviders.LITELLM_PROXY.value:
+            return _get_litellm_skills_handler().delete_skill_handler(
+                skill_id=skill_id,
+                _is_async=_is_async,
+                logging_obj=litellm_logging_obj,
+                litellm_call_id=litellm_call_id,
+            )
+
+        # Get provider config for external providers (Anthropic, etc.)
+        skills_api_provider_config: Optional[
+            BaseSkillsAPIConfig
+        ] = ProviderConfigManager.get_provider_skills_api_config(
+            provider=litellm.LlmProviders(custom_llm_provider),
+        )
+
+        if skills_api_provider_config is None:
+            raise ValueError(f"DELETE skill is not supported for {custom_llm_provider}")
+
+        # Validate environment and get headers
+        headers = extra_headers or {}
+        headers = skills_api_provider_config.validate_environment(
+            headers=headers, litellm_params=litellm_params
+        )
+
+        # Get API base
+        from litellm.llms.anthropic.common_utils import AnthropicModelInfo
+
+        api_base = AnthropicModelInfo.get_api_base(litellm_params.api_base)
+
+        # Transform request
+        url, headers = skills_api_provider_config.transform_delete_skill_request(
+            skill_id=skill_id,
+            api_base=api_base or DEFAULT_ANTHROPIC_API_BASE,
+            litellm_params=litellm_params,
+            headers=headers,
+        )
+
+        # Pre-call logging
+        litellm_logging_obj.update_environment_variables(
+            model=None,
+            optional_params={"skill_id": skill_id},
+            litellm_params={
+                "litellm_call_id": litellm_call_id,
+            },
+            custom_llm_provider=custom_llm_provider,
+        )
+
+        # Make HTTP request
+        response = base_llm_http_handler.delete_skill_handler(
+            url=url,
+            skills_api_provider_config=skills_api_provider_config,
+            custom_llm_provider=custom_llm_provider,
+            litellm_params=litellm_params,
+            logging_obj=litellm_logging_obj,
+            extra_headers=headers,
+            timeout=timeout or request_timeout,
+            _is_async=_is_async,
+            client=kwargs.get("client"),
+            shared_session=kwargs.get("shared_session"),
+        )
+
+        return response
+    except Exception as e:
+        raise litellm.exception_type(
+            model=None,
+            custom_llm_provider=custom_llm_provider,
+            original_exception=e,
+            completion_kwargs=local_vars,
+            extra_kwargs=kwargs,
+        )