cmdop-llm 0.1.0__py3-none-any.whl

cmdop_llm/__init__.py

@@ -0,0 +1,89 @@
+"""CMDOP LLM Python SDK.
+
+A drop-in replacement for OpenAI Python SDK that connects to llm.cmdop.com.
+Provides access to 200+ AI models via OpenRouter, plus custom vision/OCR endpoints.
+
+Example:
+    ```python
+    from cmdop_llm import CmdopLLM
+
+    client = CmdopLLM(api_key="your-api-key")
+
+    # Chat completion (same as OpenAI)
+    response = client.chat.completions.create(
+        model="anthropic/claude-3.5-sonnet",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+
+    # Vision analysis (CMDOP-specific)
+    result = client.vision.analyze(image_url="https://...")
+
+    # OCR (CMDOP-specific)
+    result = client.ocr.extract(image_url="https://...")
+    ```
+"""
+
+from openai import (
+    APIConnectionError,
+    APIError,
+    APIStatusError,
+    APITimeoutError,
+    AsyncStream,
+    AuthenticationError,
+    BadRequestError,
+    ConflictError,
+    InternalServerError,
+    NotFoundError,
+    OpenAIError,
+    PermissionDeniedError,
+    RateLimitError,
+    Stream,
+    UnprocessableEntityError,
+)
+from openai._types import NOT_GIVEN, NotGiven
+
+from ._client import AsyncClient, AsyncCmdopLLM, Client, CmdopLLM
+from ._version import __author__, __email__, __title__, __version__
+from .resources import AsyncOCR, AsyncVision, OCR, Vision
+from .types import OCRRequest, OCRResponse, VisionAnalyzeRequest, VisionAnalyzeResponse
+
+__all__ = [
+    # Version info
+    "__version__",
+    "__title__",
+    "__author__",
+    "__email__",
+    # Main clients
+    "CmdopLLM",
+    "AsyncCmdopLLM",
+    "Client",
+    "AsyncClient",
+    # Custom resources
+    "Vision",
+    "AsyncVision",
+    "OCR",
+    "AsyncOCR",
+    # Custom types
+    "VisionAnalyzeRequest",
+    "VisionAnalyzeResponse",
+    "OCRRequest",
+    "OCRResponse",
+    # Re-exported from OpenAI
+    "OpenAIError",
+    "APIError",
+    "APIStatusError",
+    "APIConnectionError",
+    "APITimeoutError",
+    "AuthenticationError",
+    "BadRequestError",
+    "ConflictError",
+    "NotFoundError",
+    "PermissionDeniedError",
+    "RateLimitError",
+    "UnprocessableEntityError",
+    "InternalServerError",
+    "Stream",
+    "AsyncStream",
+    "NOT_GIVEN",
+    "NotGiven",
+]

cmdop_llm/_client.py

@@ -0,0 +1,217 @@
+"""Main client classes for CMDOP LLM service."""
+
+from __future__ import annotations
+
+import os
+from typing import Mapping, Optional, Union
+
+import httpx
+from openai import AsyncOpenAI, OpenAI
+from openai._compat import cached_property
+from openai._types import NOT_GIVEN, NotGiven, Timeout
+
+from ._constants import DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, ENV_API_KEY, ENV_BASE_URL
+from .resources.ocr import AsyncOCR, OCR
+from .resources.vision import AsyncVision, Vision
+
+__all__ = ["CmdopLLM", "AsyncCmdopLLM"]
+
+
+class CmdopLLM(OpenAI):
+    """Synchronous client for CMDOP LLM service.
+
+    A drop-in replacement for OpenAI client that connects to llm.cmdop.com.
+    Provides access to 200+ AI models via OpenRouter, plus custom vision/OCR endpoints.
+
+    Example:
+        ```python
+        from cmdop_llm import CmdopLLM
+
+        # Initialize with API key
+        client = CmdopLLM(api_key="your-cmdop-api-key")
+
+        # Or use CMDOP_API_KEY environment variable
+        client = CmdopLLM()
+
+        # Chat completion (same as OpenAI)
+        response = client.chat.completions.create(
+            model="anthropic/claude-3.5-sonnet",
+            messages=[{"role": "user", "content": "Hello!"}]
+        )
+        print(response.choices[0].message.content)
+
+        # Vision analysis (CMDOP-specific)
+        result = client.vision.analyze(
+            image_url="https://example.com/image.jpg"
+        )
+        print(result.description)
+
+        # OCR text extraction (CMDOP-specific)
+        result = client.ocr.extract(
+            image_url="https://example.com/document.png"
+        )
+        print(result.text)
+        ```
+
+    Args:
+        api_key: CMDOP API key. If not provided, reads from CMDOP_API_KEY env var.
+        base_url: Override the default base URL (https://llm.cmdop.com).
+        timeout: Request timeout in seconds or httpx.Timeout object.
+        max_retries: Maximum number of retries for failed requests.
+        default_headers: Headers to include in all requests.
+        default_query: Query parameters to include in all requests.
+        http_client: Custom httpx.Client instance.
+    """
+
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str] = None,
+        base_url: Union[str, httpx.URL, None] = None,
+        timeout: Union[float, Timeout, None, NotGiven] = NOT_GIVEN,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        default_headers: Optional[Mapping[str, str]] = None,
+        default_query: Optional[Mapping[str, object]] = None,
+        http_client: Optional[httpx.Client] = None,
+    ) -> None:
+        # Get API key from environment if not provided
+        if api_key is None:
+            api_key = os.environ.get(ENV_API_KEY)
+            if api_key is None:
+                raise ValueError(
+                    f"API key is required. Set {ENV_API_KEY} environment variable "
+                    "or pass api_key parameter."
+                )
+
+        # Get base URL from environment or use default
+        if base_url is None:
+            base_url = os.environ.get(ENV_BASE_URL, DEFAULT_BASE_URL)
+
+        super().__init__(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            default_headers=default_headers,
+            default_query=default_query,
+            http_client=http_client,
+        )
+
+    @cached_property
+    def vision(self) -> Vision:
+        """Access vision analysis endpoints.
+
+        Returns:
+            Vision resource for image analysis.
+        """
+        return Vision(self)
+
+    @cached_property
+    def ocr(self) -> OCR:
+        """Access OCR text extraction endpoints.
+
+        Returns:
+            OCR resource for text extraction from images.
+        """
+        return OCR(self)
+
+
+class AsyncCmdopLLM(AsyncOpenAI):
+    """Asynchronous client for CMDOP LLM service.
+
+    Async version of CmdopLLM for use with asyncio.
+
+    Example:
+        ```python
+        import asyncio
+        from cmdop_llm import AsyncCmdopLLM
+
+        async def main():
+            client = AsyncCmdopLLM()
+
+            # Chat completion
+            response = await client.chat.completions.create(
+                model="openai/gpt-4o",
+                messages=[{"role": "user", "content": "Hello!"}]
+            )
+            print(response.choices[0].message.content)
+
+            # Streaming
+            stream = await client.chat.completions.create(
+                model="openai/gpt-4o",
+                messages=[{"role": "user", "content": "Write a poem"}],
+                stream=True
+            )
+            async for chunk in stream:
+                if chunk.choices[0].delta.content:
+                    print(chunk.choices[0].delta.content, end="")
+
+        asyncio.run(main())
+        ```
+
+    Args:
+        api_key: CMDOP API key. If not provided, reads from CMDOP_API_KEY env var.
+        base_url: Override the default base URL (https://llm.cmdop.com).
+        timeout: Request timeout in seconds or httpx.Timeout object.
+        max_retries: Maximum number of retries for failed requests.
+        default_headers: Headers to include in all requests.
+        default_query: Query parameters to include in all requests.
+        http_client: Custom httpx.AsyncClient instance.
+    """
+
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str] = None,
+        base_url: Union[str, httpx.URL, None] = None,
+        timeout: Union[float, Timeout, None, NotGiven] = NOT_GIVEN,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        default_headers: Optional[Mapping[str, str]] = None,
+        default_query: Optional[Mapping[str, object]] = None,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> None:
+        # Get API key from environment if not provided
+        if api_key is None:
+            api_key = os.environ.get(ENV_API_KEY)
+            if api_key is None:
+                raise ValueError(
+                    f"API key is required. Set {ENV_API_KEY} environment variable "
+                    "or pass api_key parameter."
+                )
+
+        # Get base URL from environment or use default
+        if base_url is None:
+            base_url = os.environ.get(ENV_BASE_URL, DEFAULT_BASE_URL)
+
+        super().__init__(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            default_headers=default_headers,
+            default_query=default_query,
+            http_client=http_client,
+        )
+
+    @cached_property
+    def vision(self) -> AsyncVision:
+        """Access vision analysis endpoints.
+
+        Returns:
+            AsyncVision resource for image analysis.
+        """
+        return AsyncVision(self)
+
+    @cached_property
+    def ocr(self) -> AsyncOCR:
+        """Access OCR text extraction endpoints.
+
+        Returns:
+            AsyncOCR resource for text extraction from images.
+        """
+        return AsyncOCR(self)
+
+
+# Aliases for convenience
+Client = CmdopLLM
+AsyncClient = AsyncCmdopLLM

cmdop_llm/_constants.py

@@ -0,0 +1,12 @@
+"""Constants for cmdop-llm package."""
+
+# Default base URL for CMDOP LLM service
+DEFAULT_BASE_URL = "https://llm.cmdop.com"
+
+# Environment variable names
+ENV_API_KEY = "CMDOP_API_KEY"
+ENV_BASE_URL = "CMDOP_BASE_URL"
+
+# Default timeout settings (seconds)
+DEFAULT_TIMEOUT = 60.0
+DEFAULT_MAX_RETRIES = 2

cmdop_llm/_version.py

@@ -0,0 +1,6 @@
+"""Version information for cmdop-llm package."""
+
+__version__ = "0.1.0"
+__title__ = "cmdop-llm"
+__author__ = "CMDOP Team"
+__email__ = "support@cmdop.com"

cmdop_llm/py.typed

@@ -0,0 +1 @@
+# PEP 561 marker file - this package supports type checking

cmdop_llm/resources/__init__.py

@@ -0,0 +1,11 @@
+"""Custom resources for CMDOP LLM service."""
+
+from .ocr import AsyncOCR, OCR
+from .vision import AsyncVision, Vision
+
+__all__ = [
+    "Vision",
+    "AsyncVision",
+    "OCR",
+    "AsyncOCR",
+]

cmdop_llm/resources/ocr.py

@@ -0,0 +1,180 @@
+"""OCR extraction resource for CMDOP LLM service."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal, Optional, Union
+
+import httpx
+from openai._compat import cached_property
+from openai._resource import AsyncAPIResource, SyncAPIResource
+from openai._types import NOT_GIVEN, Body, Headers, NotGiven, Query
+
+from ..types.ocr import OCRResponse
+
+if TYPE_CHECKING:
+    from .._client import AsyncCmdopLLM, CmdopLLM
+
+__all__ = ["OCR", "AsyncOCR"]
+
+
+class OCR(SyncAPIResource):
+    """OCR text extraction resource.
+
+    Provides text extraction from images using vision models.
+
+    Example:
+        ```python
+        from cmdop_llm import CmdopLLM
+
+        client = CmdopLLM()
+        result = client.ocr.extract(
+            image_url="https://example.com/document.png"
+        )
+        print(result.text)
+        ```
+    """
+
+    _client: CmdopLLM
+
+    @cached_property
+    def with_raw_response(self) -> OCRWithRawResponse:
+        """Access raw HTTP response data."""
+        return OCRWithRawResponse(self)
+
+    def extract(
+        self,
+        *,
+        image: Optional[str] = None,
+        image_url: Optional[str] = None,
+        model: Optional[str] = None,
+        mode: Literal["tiny", "small", "base", "gundam"] = "base",
+        fetch_image: bool = True,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: Union[float, httpx.Timeout, None, NotGiven] = NOT_GIVEN,
+    ) -> OCRResponse:
+        """Extract text from an image using OCR.
+
+        Args:
+            image: Base64-encoded image data.
+            image_url: URL of the image to extract text from.
+            model: Model to use. Defaults to server default.
+            mode: OCR quality mode ("tiny", "small", "base", "gundam").
+            fetch_image: Whether server should fetch image from URL.
+            extra_headers: Additional headers to send.
+            extra_query: Additional query parameters.
+            extra_body: Additional body parameters.
+            timeout: Request timeout.
+
+        Returns:
+            OCRResponse with extracted text.
+
+        Raises:
+            ValueError: If neither image nor image_url is provided.
+            openai.APIError: If the request fails.
+        """
+        if not image and not image_url:
+            raise ValueError("Either 'image' or 'image_url' must be provided")
+
+        body = {
+            "image": image,
+            "image_url": image_url,
+            "model": model,
+            "mode": mode,
+            "fetch_image": fetch_image,
+        }
+        # Remove None values
+        body = {k: v for k, v in body.items() if v is not None}
+
+        return self._post(
+            "/vision/ocr",
+            body=body,
+            options={
+                "extra_headers": extra_headers,
+                "extra_query": extra_query,
+                "extra_body": extra_body,
+                "timeout": timeout,
+            },
+            cast_to=OCRResponse,
+        )
+
+
+class AsyncOCR(AsyncAPIResource):
+    """Async OCR text extraction resource."""
+
+    _client: AsyncCmdopLLM
+
+    @cached_property
+    def with_raw_response(self) -> AsyncOCRWithRawResponse:
+        """Access raw HTTP response data."""
+        return AsyncOCRWithRawResponse(self)
+
+    async def extract(
+        self,
+        *,
+        image: Optional[str] = None,
+        image_url: Optional[str] = None,
+        model: Optional[str] = None,
+        mode: Literal["tiny", "small", "base", "gundam"] = "base",
+        fetch_image: bool = True,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: Union[float, httpx.Timeout, None, NotGiven] = NOT_GIVEN,
+    ) -> OCRResponse:
+        """Extract text from an image using OCR (async).
+
+        See OCR.extract for full documentation.
+        """
+        if not image and not image_url:
+            raise ValueError("Either 'image' or 'image_url' must be provided")
+
+        body = {
+            "image": image,
+            "image_url": image_url,
+            "model": model,
+            "mode": mode,
+            "fetch_image": fetch_image,
+        }
+        body = {k: v for k, v in body.items() if v is not None}
+
+        return await self._post(
+            "/vision/ocr",
+            body=body,
+            options={
+                "extra_headers": extra_headers,
+                "extra_query": extra_query,
+                "extra_body": extra_body,
+                "timeout": timeout,
+            },
+            cast_to=OCRResponse,
+        )
+
+
+class OCRWithRawResponse:
+    """Raw response wrapper for OCR resource."""
+
+    def __init__(self, ocr: OCR) -> None:
+        self._ocr = ocr
+
+    def extract(self, **kwargs) -> httpx.Response:  # type: ignore
+        """Get raw response from extract."""
+        return self._ocr._client.with_raw_response._post(  # type: ignore
+            "/vision/ocr",
+            body=kwargs,
+        )
+
+
+class AsyncOCRWithRawResponse:
+    """Raw response wrapper for AsyncOCR resource."""
+
+    def __init__(self, ocr: AsyncOCR) -> None:
+        self._ocr = ocr
+
+    async def extract(self, **kwargs) -> httpx.Response:  # type: ignore
+        """Get raw response from extract."""
+        return await self._ocr._client.with_raw_response._post(  # type: ignore
+            "/vision/ocr",
+            body=kwargs,
+        )

cmdop_llm/resources/vision.py

@@ -0,0 +1,186 @@
+"""Vision analysis resource for CMDOP LLM service."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal, Optional, Union
+
+import httpx
+from openai._compat import cached_property
+from openai._resource import AsyncAPIResource, SyncAPIResource
+from openai._types import NOT_GIVEN, Body, Headers, NotGiven, Query
+
+from ..types.vision import VisionAnalyzeResponse
+
+if TYPE_CHECKING:
+    from .._client import AsyncCmdopLLM, CmdopLLM
+
+__all__ = ["Vision", "AsyncVision"]
+
+
+class Vision(SyncAPIResource):
+    """Vision analysis resource.
+
+    Provides image analysis capabilities using vision models.
+
+    Example:
+        ```python
+        from cmdop_llm import CmdopLLM
+
+        client = CmdopLLM()
+        result = client.vision.analyze(
+            image_url="https://example.com/image.jpg",
+            prompt="Describe this image"
+        )
+        print(result.description)
+        ```
+    """
+
+    _client: CmdopLLM
+
+    @cached_property
+    def with_raw_response(self) -> VisionWithRawResponse:
+        """Access raw HTTP response data."""
+        return VisionWithRawResponse(self)
+
+    def analyze(
+        self,
+        *,
+        image: Optional[str] = None,
+        image_url: Optional[str] = None,
+        prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        ocr_mode: Literal["tiny", "small", "base", "gundam"] = "base",
+        fetch_image: bool = True,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: Union[float, httpx.Timeout, None, NotGiven] = NOT_GIVEN,
+    ) -> VisionAnalyzeResponse:
+        """Analyze an image using a vision model.
+
+        Args:
+            image: Base64-encoded image data.
+            image_url: URL of the image to analyze.
+            prompt: Custom prompt for the analysis.
+            model: Model to use. Defaults to server default.
+            ocr_mode: OCR quality mode ("tiny", "small", "base", "gundam").
+            fetch_image: Whether server should fetch image from URL.
+            extra_headers: Additional headers to send.
+            extra_query: Additional query parameters.
+            extra_body: Additional body parameters.
+            timeout: Request timeout.
+
+        Returns:
+            VisionAnalyzeResponse with extracted text and description.
+
+        Raises:
+            ValueError: If neither image nor image_url is provided.
+            openai.APIError: If the request fails.
+        """
+        if not image and not image_url:
+            raise ValueError("Either 'image' or 'image_url' must be provided")
+
+        body = {
+            "image": image,
+            "image_url": image_url,
+            "prompt": prompt,
+            "model": model,
+            "ocr_mode": ocr_mode,
+            "fetch_image": fetch_image,
+        }
+        # Remove None values
+        body = {k: v for k, v in body.items() if v is not None}
+
+        return self._post(
+            "/vision/analyze",
+            body=body,
+            options={
+                "extra_headers": extra_headers,
+                "extra_query": extra_query,
+                "extra_body": extra_body,
+                "timeout": timeout,
+            },
+            cast_to=VisionAnalyzeResponse,
+        )
+
+
+class AsyncVision(AsyncAPIResource):
+    """Async vision analysis resource."""
+
+    _client: AsyncCmdopLLM
+
+    @cached_property
+    def with_raw_response(self) -> AsyncVisionWithRawResponse:
+        """Access raw HTTP response data."""
+        return AsyncVisionWithRawResponse(self)
+
+    async def analyze(
+        self,
+        *,
+        image: Optional[str] = None,
+        image_url: Optional[str] = None,
+        prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        ocr_mode: Literal["tiny", "small", "base", "gundam"] = "base",
+        fetch_image: bool = True,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: Union[float, httpx.Timeout, None, NotGiven] = NOT_GIVEN,
+    ) -> VisionAnalyzeResponse:
+        """Analyze an image using a vision model (async).
+
+        See Vision.analyze for full documentation.
+        """
+        if not image and not image_url:
+            raise ValueError("Either 'image' or 'image_url' must be provided")
+
+        body = {
+            "image": image,
+            "image_url": image_url,
+            "prompt": prompt,
+            "model": model,
+            "ocr_mode": ocr_mode,
+            "fetch_image": fetch_image,
+        }
+        body = {k: v for k, v in body.items() if v is not None}
+
+        return await self._post(
+            "/vision/analyze",
+            body=body,
+            options={
+                "extra_headers": extra_headers,
+                "extra_query": extra_query,
+                "extra_body": extra_body,
+                "timeout": timeout,
+            },
+            cast_to=VisionAnalyzeResponse,
+        )
+
+
+class VisionWithRawResponse:
+    """Raw response wrapper for Vision resource."""
+
+    def __init__(self, vision: Vision) -> None:
+        self._vision = vision
+
+    def analyze(self, **kwargs) -> httpx.Response:  # type: ignore
+        """Get raw response from analyze."""
+        return self._vision._client.with_raw_response._post(  # type: ignore
+            "/vision/analyze",
+            body=kwargs,
+        )
+
+
+class AsyncVisionWithRawResponse:
+    """Raw response wrapper for AsyncVision resource."""
+
+    def __init__(self, vision: AsyncVision) -> None:
+        self._vision = vision
+
+    async def analyze(self, **kwargs) -> httpx.Response:  # type: ignore
+        """Get raw response from analyze."""
+        return await self._vision._client.with_raw_response._post(  # type: ignore
+            "/vision/analyze",
+            body=kwargs,
+        )

cmdop_llm/types/__init__.py

@@ -0,0 +1,11 @@
+"""Type definitions for cmdop-llm custom endpoints."""
+
+from .ocr import OCRRequest, OCRResponse
+from .vision import VisionAnalyzeRequest, VisionAnalyzeResponse
+
+__all__ = [
+    "VisionAnalyzeRequest",
+    "VisionAnalyzeResponse",
+    "OCRRequest",
+    "OCRResponse",
+]

cmdop_llm/types/ocr.py

@@ -0,0 +1,50 @@
+"""Type definitions for OCR endpoint."""
+
+from typing import Literal, Optional
+
+from pydantic import BaseModel, model_validator
+
+
+class OCRRequest(BaseModel):
+    """Request for OCR text extraction."""
+
+    image: Optional[str] = None
+    """Base64-encoded image data."""
+
+    image_url: Optional[str] = None
+    """URL of the image to extract text from."""
+
+    model: Optional[str] = None
+    """Model to use for OCR. Defaults to server default."""
+
+    mode: Literal["tiny", "small", "base", "gundam"] = "base"
+    """OCR mode affecting quality and speed."""
+
+    fetch_image: bool = True
+    """Whether to fetch image from URL on server side."""
+
+    @model_validator(mode="after")
+    def validate_image_source(self) -> "OCRRequest":
+        """Ensure at least one image source is provided."""
+        if not self.image and not self.image_url:
+            raise ValueError("Either 'image' or 'image_url' must be provided")
+        return self
+
+
+class OCRResponse(BaseModel):
+    """Response from OCR extraction."""
+
+    text: str
+    """Extracted text content."""
+
+    model: str
+    """Model used for extraction."""
+
+    cost_usd: float
+    """Cost of the request in USD."""
+
+    tokens_input: int
+    """Number of input tokens used."""
+
+    tokens_output: int
+    """Number of output tokens generated."""

cmdop_llm/types/vision.py

@@ -0,0 +1,59 @@
+"""Type definitions for vision analysis endpoint."""
+
+from typing import Literal, Optional
+
+from pydantic import BaseModel, model_validator
+
+
+class VisionAnalyzeRequest(BaseModel):
+    """Request for vision analysis."""
+
+    image: Optional[str] = None
+    """Base64-encoded image data."""
+
+    image_url: Optional[str] = None
+    """URL of the image to analyze."""
+
+    prompt: Optional[str] = None
+    """Custom prompt for the analysis."""
+
+    model: Optional[str] = None
+    """Model to use for analysis. Defaults to server default."""
+
+    ocr_mode: Literal["tiny", "small", "base", "gundam"] = "base"
+    """OCR mode for text extraction quality."""
+
+    fetch_image: bool = True
+    """Whether to fetch image from URL on server side."""
+
+    @model_validator(mode="after")
+    def validate_image_source(self) -> "VisionAnalyzeRequest":
+        """Ensure at least one image source is provided."""
+        if not self.image and not self.image_url:
+            raise ValueError("Either 'image' or 'image_url' must be provided")
+        return self
+
+
+class VisionAnalyzeResponse(BaseModel):
+    """Response from vision analysis."""
+
+    extracted_text: str
+    """Text extracted from the image."""
+
+    description: str
+    """Description of the image content."""
+
+    language: Optional[str] = None
+    """Detected language of the text."""
+
+    model: str
+    """Model used for analysis."""
+
+    cost_usd: float
+    """Cost of the request in USD."""
+
+    tokens_input: int
+    """Number of input tokens used."""
+
+    tokens_output: int
+    """Number of output tokens generated."""

cmdop_llm-0.1.0.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: cmdop-llm
+Version: 0.1.0
+Summary: Python SDK for CMDOP LLM Service - OpenAI-compatible API for 200+ AI models
+Project-URL: Homepage, https://cmdop.com
+Project-URL: Documentation, https://sdk.cmdop.com
+Project-URL: Repository, https://github.com/markolofsen/cmdop-client
+Project-URL: Issues, https://github.com/markolofsen/cmdop-client/issues
+Author-email: CMDOP Team <support@cmdop.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,anthropic,api,chat,claude,cmdop,gpt,llm,openai,openrouter
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx<1,>=0.23.0
+Requires-Dist: openai<3.0.0,>=1.0.0
+Requires-Dist: pydantic<3,>=2.0.0
+Requires-Dist: typing-extensions>=4.5.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pyright>=1.1.300; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: respx>=0.20.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# CMDOP LLM Python SDK
+
+Python SDK for CMDOP LLM Service - OpenAI-compatible API for 200+ AI models.
+
+## Installation
+
+```bash
+pip install cmdop-llm
+```
+
+## Quick Start
+
+```python
+from cmdop_llm import CmdopLLM
+
+client = CmdopLLM(api_key="your-api-key")
+
+response = client.chat.completions.create(
+    model="anthropic/claude-3.5-sonnet",
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+print(response.choices[0].message.content)
+```
+
+## Features
+
+- **Drop-in OpenAI replacement** - Same API, different models
+- **200+ Models** - GPT-4, Claude, Llama, Mistral, Gemini via single endpoint
+- **Streaming** - Real-time token streaming
+- **Vision & OCR** - Image analysis and text extraction
+- **Image Generation** - FLUX, DALL-E and other models
+- **Async Support** - Full async/await support
+
+## Environment Variables
+
+```bash
+export CMDOP_API_KEY="your-api-key"
+export CMDOP_BASE_URL="https://llm.cmdop.com"  # Optional, default
+```
+
+## Usage Examples
+
+### Chat Completion
+
+```python
+from cmdop_llm import CmdopLLM
+
+client = CmdopLLM()
+
+response = client.chat.completions.create(
+    model="openai/gpt-4o",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "Explain quantum computing."}
+    ],
+    temperature=0.7,
+    max_tokens=1000,
+)
+print(response.choices[0].message.content)
+```
+
+### Streaming
+
+```python
+stream = client.chat.completions.create(
+    model="anthropic/claude-3.5-sonnet",
+    messages=[{"role": "user", "content": "Write a poem."}],
+    stream=True,
+)
+
+for chunk in stream:
+    if chunk.choices[0].delta.content:
+        print(chunk.choices[0].delta.content, end="")
+```
+
+### Vision Analysis
+
+```python
+result = client.vision.analyze(
+    image_url="https://example.com/image.jpg",
+    prompt="Describe this image"
+)
+print(result.description)
+print(result.extracted_text)
+```
+
+### OCR Text Extraction
+
+```python
+result = client.ocr.extract(
+    image_url="https://example.com/document.png"
+)
+print(result.text)
+```
+
+### Image Generation
+
+```python
+response = client.images.generate(
+    model="black-forest-labs/FLUX.1-schnell",
+    prompt="A futuristic cityscape",
+    size="1024x1024",
+)
+print(response.data[0].url)
+```
+
+### Async Usage
+
+```python
+import asyncio
+from cmdop_llm import AsyncCmdopLLM
+
+async def main():
+    client = AsyncCmdopLLM()
+
+    response = await client.chat.completions.create(
+        model="openai/gpt-4o",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+    print(response.choices[0].message.content)
+
+asyncio.run(main())
+```
+
+## Available Models
+
+Access 200+ models including:
+
+- **OpenAI**: gpt-4o, gpt-4o-mini, gpt-4-turbo
+- **Anthropic**: claude-3.5-sonnet, claude-3-opus, claude-3-haiku
+- **Google**: gemini-pro, gemini-1.5-pro
+- **Meta**: llama-3.1-405b, llama-3.1-70b
+- **Mistral**: mistral-large, mixtral-8x22b
+- **Image**: FLUX.1-schnell, FLUX.1-pro, stable-diffusion-xl
+
+Use model format: `provider/model-name` (e.g., `openai/gpt-4o`)
+
+## API Reference
+
+### CmdopLLM
+
+```python
+CmdopLLM(
+    api_key: str = None,       # From CMDOP_API_KEY env if not set
+    base_url: str = None,      # Default: https://llm.cmdop.com
+    timeout: float = None,     # Request timeout
+    max_retries: int = 2,      # Retry count
+)
+```
+
+### Resources
+
+- `client.chat.completions` - Chat completions (OpenAI compatible)
+- `client.images` - Image generation (OpenAI compatible)
+- `client.models` - List available models
+- `client.vision` - Vision analysis (CMDOP specific)
+- `client.ocr` - OCR extraction (CMDOP specific)
+
+## License
+
+MIT

cmdop_llm-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+cmdop_llm/__init__.py,sha256=LaW6PRIW-GO8ipcsvfLtA2_lNI4MvJsUiL4GwvdiKVc,2140
+cmdop_llm/_client.py,sha256=Y_ycGrvkuBIzgxx2HWg95W3piJ1Ml5CRSMUwyh4rYFY,7032
+cmdop_llm/_constants.py,sha256=bxyJOaffvTUPRn12GveQYeFRof8iLpw8Xgi_z_usgJQ,301
+cmdop_llm/_version.py,sha256=-XsuXf8DEZujLc8xXXaLl82JH7PEwJ1nbZJqHaYy3FI,154
+cmdop_llm/py.typed,sha256=qww23I-O7yv_Kf5Wu2UW3r8K1Vd12UDESBl5tmzRSI0,60
+cmdop_llm/resources/__init__.py,sha256=Jqx7K-ijPxSahuYBJQHT9xngSWgrAeB0WF4TEiOsHEw,193
+cmdop_llm/resources/ocr.py,sha256=I44rXAWgqDhQFBF6ewqBw9SQoWZc-3ENwe-_iIk0MzY,5438
+cmdop_llm/resources/vision.py,sha256=xRr4eQEALoxyPw3VUxWibCMNelT4_EeQyHIGxFvQ9nU,5852
+cmdop_llm/types/__init__.py,sha256=uuB068ElAXawfftqneg9Cb9CZxq3TZuOCkwZm8l6-hQ,270
+cmdop_llm/types/ocr.py,sha256=WOWV1OYGKoZjmghrOnff4274rrnI4qQEKv9ppDNlXa0,1312
+cmdop_llm/types/vision.py,sha256=nsvG58ggFRb6cRAClcbsaesHA1nu4BYbH5NleZR8UAg,1584
+cmdop_llm-0.1.0.dist-info/METADATA,sha256=SDznx7azTjqwelhjT6SsITtJ3SiYeAYbSz202lEyUwk,5147
+cmdop_llm-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+cmdop_llm-0.1.0.dist-info/licenses/LICENSE,sha256=8flEwqCzbjvfOljG-NWHrUXYYyNVOpWMLXNyvEeuiDA,1062
+cmdop_llm-0.1.0.dist-info/RECORD,,

cmdop_llm-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cmdop_llm-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CMDOP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.