sdkrouter 0.1.1__py3-none-any.whl

sdkrouter/tools/models.py

@@ -0,0 +1,196 @@
+"""LLM Models tool using generated API client."""
+
+from typing import Optional
+
+from .._config import SDKConfig
+from .._api.client import (
+    BaseResource,
+    AsyncBaseResource,
+    SyncModelsLlmModelsAPI,
+    ModelsLlmModelsAPI,
+)
+from .._api.generated.models.models__api__llm_models.models import (
+    LLMModelList,
+    LLMModelDetail,
+    PaginatedLLMModelListList,
+    ProvidersResponse,
+    StatsResponse,
+    CostCalculationRequestRequest,
+    CostCalculationResponse,
+)
+
+
+class ModelsResource(BaseResource):
+    """LLM Models tool (sync).
+
+    Uses generated SyncModelsLlmModelsAPI client.
+
+    Example:
+        ```python
+        from sdkrouter import SDKRouter
+
+        client = SDKRouter(api_key="your-api-key")
+
+        # List all models with pagination
+        models = client.models.list(page=1, page_size=20)
+        for model in models.results:
+            print(f"{model.model_id}: {model.name}")
+
+        # Get model details
+        model = client.models.get("openai/gpt-4o")
+        print(f"Context: {model.context_length} tokens")
+
+        # Calculate cost
+        cost = client.models.calculate_cost(
+            "openai/gpt-4o",
+            input_tokens=1000,
+            output_tokens=500
+        )
+        print(f"Cost: ${cost.total_cost_usd}")
+
+        # Get providers list
+        providers = client.models.providers()
+        for p in providers.providers:
+            print(f"{p.name}: {p.model_count} models")
+
+        # Get statistics
+        stats = client.models.stats()
+        print(f"Total models: {stats.total_models}")
+        ```
+    """
+
+    def __init__(self, config: SDKConfig):
+        super().__init__(config)
+        self._api = SyncModelsLlmModelsAPI(self._http_client)
+
+    def list(
+        self,
+        *,
+        page: int = 1,
+        page_size: int = 20,
+    ) -> PaginatedLLMModelListList:
+        """
+        List available LLM models with pagination.
+
+        Args:
+            page: Page number (1-based)
+            page_size: Number of results per page
+
+        Returns:
+            Paginated list of LLM models.
+        """
+        return self._api.list(page=page, page_size=page_size)
+
+    def get(self, model_id: str) -> LLMModelDetail:
+        """
+        Get detailed information about a specific model.
+
+        Args:
+            model_id: Model identifier (e.g., 'openai/gpt-4o')
+
+        Returns:
+            Model details including pricing, capabilities, etc.
+        """
+        return self._api.retrieve(model_id)
+
+    def calculate_cost(
+        self,
+        model_id: str,
+        *,
+        input_tokens: int,
+        output_tokens: int,
+    ) -> CostCalculationResponse:
+        """
+        Calculate cost for a request.
+
+        Args:
+            model_id: Model identifier
+            input_tokens: Number of input tokens
+            output_tokens: Number of output tokens
+
+        Returns:
+            Cost calculation result.
+        """
+        request = CostCalculationRequestRequest(
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+        )
+        return self._api.calculate_cost_create(model_id, request)
+
+    def providers(self) -> ProvidersResponse:
+        """
+        Get list of available providers.
+
+        Returns:
+            List of providers with model counts.
+        """
+        return self._api.providers_retrieve()
+
+    def stats(self) -> StatsResponse:
+        """
+        Get model statistics.
+
+        Returns:
+            Statistics about available models.
+        """
+        return self._api.stats_retrieve()
+
+
+class AsyncModelsResource(AsyncBaseResource):
+    """LLM Models tool (async).
+
+    Uses generated ModelsLlmModelsAPI client.
+    """
+
+    def __init__(self, config: SDKConfig):
+        super().__init__(config)
+        self._api = ModelsLlmModelsAPI(self._http_client)
+
+    async def list(
+        self,
+        *,
+        page: int = 1,
+        page_size: int = 20,
+    ) -> PaginatedLLMModelListList:
+        """List available LLM models with pagination."""
+        return await self._api.list(page=page, page_size=page_size)
+
+    async def get(self, model_id: str) -> LLMModelDetail:
+        """Get detailed information about a specific model."""
+        return await self._api.retrieve(model_id)
+
+    async def calculate_cost(
+        self,
+        model_id: str,
+        *,
+        input_tokens: int,
+        output_tokens: int,
+    ) -> CostCalculationResponse:
+        """Calculate cost for a request."""
+        request = CostCalculationRequestRequest(
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+        )
+        return await self._api.calculate_cost_create(model_id, request)
+
+    async def providers(self) -> ProvidersResponse:
+        """Get list of available providers."""
+        return await self._api.providers_retrieve()
+
+    async def stats(self) -> StatsResponse:
+        """Get model statistics."""
+        return await self._api.stats_retrieve()
+
+
+__all__ = [
+    "ModelsResource",
+    "AsyncModelsResource",
+    # Models
+    "LLMModelList",
+    "LLMModelDetail",
+    "PaginatedLLMModelListList",
+    "ProvidersResponse",
+    "StatsResponse",
+    "CostCalculationRequestRequest",
+    "CostCalculationResponse",
+]

sdkrouter/tools/shortlinks.py

@@ -0,0 +1,165 @@
+"""URL shortening tool using generated API client."""
+
+from datetime import datetime
+from typing import Optional
+
+import httpx
+
+from .._config import SDKConfig
+from .._api.client import (
+    BaseResource,
+    AsyncBaseResource,
+    SyncShortlinksShortlinksAPI,
+    ShortlinksShortlinksAPI,
+)
+from .._api.generated.shortlinks.shortlinks__api__shortlinks.models import (
+    ShortLinkList,
+    ShortLinkDetail,
+    ShortLinkCreate,
+    ShortLinkCreateRequest,
+    PaginatedShortLinkListList,
+    ShortLinkStats,
+)
+
+
+class ShortlinksResource(BaseResource):
+    """URL shortening tool (sync).
+
+    Uses generated SyncShortlinksShortlinksAPI client.
+    """
+
+    def __init__(self, config: SDKConfig):
+        super().__init__(config)
+        self._api = SyncShortlinksShortlinksAPI(self._http_client)
+
+    def create(
+        self,
+        target_url: str,
+        *,
+        custom_slug: Optional[str] = None,
+        expires_at: Optional[datetime] = None,
+        max_hits: Optional[int] = None,
+        metadata: Optional[dict] = None,
+    ) -> ShortLinkCreate:
+        """
+        Create a short link.
+
+        Args:
+            target_url: URL to redirect to
+            custom_slug: Custom slug (optional)
+            expires_at: Expiration datetime (optional)
+            max_hits: Max redirects (optional)
+            metadata: Additional metadata
+
+        Returns:
+            ShortLinkCreate with link info.
+        """
+        # Build request with only non-None values
+        kwargs = {"target_url": target_url}
+        if custom_slug is not None:
+            kwargs["custom_slug"] = custom_slug
+        if expires_at is not None:
+            kwargs["expires_at"] = expires_at.isoformat()
+        if max_hits is not None:
+            kwargs["max_hits"] = max_hits
+        if metadata is not None:
+            kwargs["metadata"] = metadata
+        request = ShortLinkCreateRequest(**kwargs)
+        return self._api.create(request)
+
+    def get(self, code: str) -> ShortLinkDetail:
+        """Get link details by code."""
+        return self._api.retrieve(code)
+
+    def list(
+        self,
+        *,
+        page: int = 1,
+        page_size: int = 20,
+    ) -> PaginatedShortLinkListList:
+        """List short links."""
+        return self._api.list(page=page, page_size=page_size)
+
+    def delete(self, code: str) -> bool:
+        """Deactivate a short link."""
+        try:
+            self._api.destroy(code)
+            return True
+        except httpx.HTTPStatusError:
+            return False
+
+    def stats(self) -> ShortLinkStats:
+        """Get link statistics."""
+        return self._api.stats_retrieve()
+
+
+class AsyncShortlinksResource(AsyncBaseResource):
+    """URL shortening tool (async).
+
+    Uses generated ShortlinksShortlinksAPI client.
+    """
+
+    def __init__(self, config: SDKConfig):
+        super().__init__(config)
+        self._api = ShortlinksShortlinksAPI(self._http_client)
+
+    async def create(
+        self,
+        target_url: str,
+        *,
+        custom_slug: Optional[str] = None,
+        expires_at: Optional[datetime] = None,
+        max_hits: Optional[int] = None,
+        metadata: Optional[dict] = None,
+    ) -> ShortLinkCreate:
+        """Create a short link."""
+        # Build request with only non-None values
+        kwargs = {"target_url": target_url}
+        if custom_slug is not None:
+            kwargs["custom_slug"] = custom_slug
+        if expires_at is not None:
+            kwargs["expires_at"] = expires_at.isoformat()
+        if max_hits is not None:
+            kwargs["max_hits"] = max_hits
+        if metadata is not None:
+            kwargs["metadata"] = metadata
+        request = ShortLinkCreateRequest(**kwargs)
+        return await self._api.create(request)
+
+    async def get(self, code: str) -> ShortLinkDetail:
+        """Get link details by code."""
+        return await self._api.retrieve(code)
+
+    async def list(
+        self,
+        *,
+        page: int = 1,
+        page_size: int = 20,
+    ) -> PaginatedShortLinkListList:
+        """List short links."""
+        return await self._api.list(page=page, page_size=page_size)
+
+    async def delete(self, code: str) -> bool:
+        """Deactivate a short link."""
+        try:
+            await self._api.destroy(code)
+            return True
+        except httpx.HTTPStatusError:
+            return False
+
+    async def stats(self) -> ShortLinkStats:
+        """Get link statistics."""
+        return await self._api.stats_retrieve()
+
+
+__all__ = [
+    "ShortlinksResource",
+    "AsyncShortlinksResource",
+    # Models
+    "ShortLinkList",
+    "ShortLinkDetail",
+    "ShortLinkCreate",
+    "ShortLinkCreateRequest",
+    "PaginatedShortLinkListList",
+    "ShortLinkStats",
+]

sdkrouter/tools/vision.py

@@ -0,0 +1,173 @@
+"""Vision analysis tool using generated API client."""
+
+from typing import Optional
+
+from .._config import SDKConfig
+from .._api.client import (
+    BaseResource,
+    AsyncBaseResource,
+    SyncVisionVisionAPI,
+    VisionVisionAPI,
+)
+from .._api.generated.vision.vision__api__vision.models import (
+    VisionAnalyzeRequestRequest,
+    VisionAnalyzeResponse,
+    OCRRequestRequest,
+    OCRResponse,
+    VisionModelsResponse,
+)
+from .._api.generated.vision.enums import (
+    OCRRequestRequestMode,
+    VisionAnalyzeRequestRequestModelQuality,
+)
+
+
+class VisionResource(BaseResource):
+    """Vision analysis tool (sync).
+
+    Uses generated SyncVisionVisionAPI client.
+    """
+
+    def __init__(self, config: SDKConfig):
+        super().__init__(config)
+        self._api = SyncVisionVisionAPI(self._http_client)
+
+    def analyze(
+        self,
+        *,
+        image: Optional[str] = None,
+        image_url: Optional[str] = None,
+        prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        model_quality: Optional[VisionAnalyzeRequestRequestModelQuality] = None,
+        fetch_image: Optional[bool] = None,
+        max_tokens: Optional[int] = None,
+    ) -> VisionAnalyzeResponse:
+        """Analyze an image with vision model."""
+        # Build request with only non-None values
+        kwargs = {}
+        if image is not None:
+            kwargs["image"] = image
+        if image_url is not None:
+            kwargs["image_url"] = image_url
+        if prompt is not None:
+            kwargs["prompt"] = prompt
+        if model is not None:
+            kwargs["model"] = model
+        if model_quality is not None:
+            kwargs["model_quality"] = model_quality
+        if fetch_image is not None:
+            kwargs["fetch_image"] = fetch_image
+        if max_tokens is not None:
+            kwargs["max_tokens"] = max_tokens
+        request = VisionAnalyzeRequestRequest(**kwargs)
+        return self._api.analyze_create(request)
+
+    def ocr(
+        self,
+        *,
+        image: Optional[str] = None,
+        image_url: Optional[str] = None,
+        mode: Optional[OCRRequestRequestMode] = None,
+        language_hint: Optional[str] = None,
+    ) -> OCRResponse:
+        """Extract text from image using OCR."""
+        # Build request with only non-None values
+        kwargs = {}
+        if image is not None:
+            kwargs["image"] = image
+        if image_url is not None:
+            kwargs["image_url"] = image_url
+        if mode is not None:
+            kwargs["mode"] = mode
+        if language_hint is not None:
+            kwargs["language_hint"] = language_hint
+        request = OCRRequestRequest(**kwargs)
+        return self._api.ocr_create(request)
+
+    def models(self) -> VisionModelsResponse:
+        """Get supported vision models."""
+        return self._api.models_retrieve()
+
+
+class AsyncVisionResource(AsyncBaseResource):
+    """Vision analysis tool (async).
+
+    Uses generated VisionVisionAPI client.
+    """
+
+    def __init__(self, config: SDKConfig):
+        super().__init__(config)
+        self._api = VisionVisionAPI(self._http_client)
+
+    async def analyze(
+        self,
+        *,
+        image: Optional[str] = None,
+        image_url: Optional[str] = None,
+        prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        model_quality: Optional[VisionAnalyzeRequestRequestModelQuality] = None,
+        fetch_image: Optional[bool] = None,
+        max_tokens: Optional[int] = None,
+    ) -> VisionAnalyzeResponse:
+        """Analyze an image with vision model."""
+        # Build request with only non-None values
+        kwargs = {}
+        if image is not None:
+            kwargs["image"] = image
+        if image_url is not None:
+            kwargs["image_url"] = image_url
+        if prompt is not None:
+            kwargs["prompt"] = prompt
+        if model is not None:
+            kwargs["model"] = model
+        if model_quality is not None:
+            kwargs["model_quality"] = model_quality
+        if fetch_image is not None:
+            kwargs["fetch_image"] = fetch_image
+        if max_tokens is not None:
+            kwargs["max_tokens"] = max_tokens
+        request = VisionAnalyzeRequestRequest(**kwargs)
+        return await self._api.analyze_create(request)
+
+    async def ocr(
+        self,
+        *,
+        image: Optional[str] = None,
+        image_url: Optional[str] = None,
+        mode: Optional[OCRRequestRequestMode] = None,
+        language_hint: Optional[str] = None,
+    ) -> OCRResponse:
+        """Extract text from image using OCR."""
+        # Build request with only non-None values
+        kwargs = {}
+        if image is not None:
+            kwargs["image"] = image
+        if image_url is not None:
+            kwargs["image_url"] = image_url
+        if mode is not None:
+            kwargs["mode"] = mode
+        if language_hint is not None:
+            kwargs["language_hint"] = language_hint
+        request = OCRRequestRequest(**kwargs)
+        return await self._api.ocr_create(request)
+
+    async def models(self) -> VisionModelsResponse:
+        """Get supported vision models."""
+        return await self._api.models_retrieve()
+
+
+__all__ = [
+    "VisionResource",
+    "AsyncVisionResource",
+    # Models
+    "VisionAnalyzeRequestRequest",
+    "VisionAnalyzeResponse",
+    "OCRRequestRequest",
+    "OCRResponse",
+    "VisionModelsResponse",
+    # Enums
+    "OCRRequestRequestMode",
+    "VisionAnalyzeRequestRequestModelQuality",
+]

sdkrouter/utils/__init__.py

@@ -0,0 +1,27 @@
+"""SDK utilities for token counting, cost calculation, and more."""
+
+from .tokens import (
+    TokenCounter,
+    count_tokens,
+    count_messages_tokens,
+    estimate_image_tokens,
+    get_optimal_detail_mode,
+)
+from .parsing import (
+    ResponseFormatT,
+    to_strict_json_schema,
+    type_to_response_format,
+)
+
+__all__ = [
+    # Token utilities
+    "TokenCounter",
+    "count_tokens",
+    "count_messages_tokens",
+    "estimate_image_tokens",
+    "get_optimal_detail_mode",
+    # Parsing utilities
+    "ResponseFormatT",
+    "to_strict_json_schema",
+    "type_to_response_format",
+]

sdkrouter/utils/parsing.py

@@ -0,0 +1,109 @@
+"""Utilities for structured output parsing with Pydantic models."""
+
+from typing import Any, Type, TypeVar
+
+from pydantic import BaseModel
+
+ResponseFormatT = TypeVar("ResponseFormatT", bound=BaseModel)
+
+
+def to_strict_json_schema(model: Type[BaseModel]) -> dict[str, Any]:
+    """
+    Convert Pydantic model to strict JSON Schema for OpenAI API.
+
+    Strict mode requires:
+    - additionalProperties: false at all levels
+    - All properties must be in required array
+
+    Args:
+        model: Pydantic model class
+
+    Returns:
+        JSON Schema dict compatible with OpenAI strict mode
+    """
+    schema = model.model_json_schema()
+    return _ensure_strict_schema(schema)
+
+
+def _ensure_strict_schema(schema: dict[str, Any]) -> dict[str, Any]:
+    """
+    Make schema strict (additionalProperties: false, all required).
+
+    Recursively processes nested objects and $defs.
+
+    Args:
+        schema: JSON Schema dict
+
+    Returns:
+        Modified schema with strict mode settings
+    """
+    schema = schema.copy()
+
+    # Process $defs (referenced schemas)
+    if "$defs" in schema:
+        new_defs = {}
+        for name, definition in schema["$defs"].items():
+            new_defs[name] = _ensure_strict_schema(definition)
+        schema["$defs"] = new_defs
+
+    # Set additionalProperties: false for objects
+    if schema.get("type") == "object":
+        schema["additionalProperties"] = False
+
+        # Make all properties required
+        if "properties" in schema:
+            schema["required"] = list(schema["properties"].keys())
+
+            # Process nested properties
+            new_props = {}
+            for prop_name, prop_schema in schema["properties"].items():
+                new_props[prop_name] = _ensure_strict_schema(prop_schema)
+            schema["properties"] = new_props
+
+    # Process array items
+    if schema.get("type") == "array" and "items" in schema:
+        schema["items"] = _ensure_strict_schema(schema["items"])
+
+    # Process anyOf/oneOf/allOf
+    for key in ("anyOf", "oneOf", "allOf"):
+        if key in schema:
+            schema[key] = [_ensure_strict_schema(item) for item in schema[key]]
+
+    return schema
+
+
+def type_to_response_format(response_format: Type[BaseModel]) -> dict[str, Any]:
+    """
+    Convert Pydantic model to OpenAI response_format parameter.
+
+    Args:
+        response_format: Pydantic model class for response parsing
+
+    Returns:
+        Dict compatible with OpenAI response_format parameter
+
+    Example:
+        >>> class Answer(BaseModel):
+        ...     text: str
+        ...     confidence: float
+        >>> fmt = type_to_response_format(Answer)
+        >>> fmt["type"]
+        'json_schema'
+        >>> fmt["json_schema"]["strict"]
+        True
+    """
+    return {
+        "type": "json_schema",
+        "json_schema": {
+            "name": response_format.__name__,
+            "schema": to_strict_json_schema(response_format),
+            "strict": True,
+        },
+    }
+
+
+__all__ = [
+    "ResponseFormatT",
+    "to_strict_json_schema",
+    "type_to_response_format",
+]