ccs-llmconnector 1.1.2__py3-none-any.whl → 1.1.4__py3-none-any.whl

{ccs_llmconnector-1.1.2.dist-info → ccs_llmconnector-1.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccs-llmconnector
-Version: 1.1.2
+Version: 1.1.4
 Summary: Lightweight wrapper around different LLM provider Python SDK Responses APIs.
 Author: CCS
 License: MIT

ccs_llmconnector-1.1.4.dist-info/RECORD

@@ -0,0 +1,16 @@
+ccs_llmconnector-1.1.4.dist-info/licenses/LICENSE,sha256=rPcz2YmBB9VUWZTLJcRO_B4jKDpqmGRYi2eSI-unysg,1083
+llmconnector/__init__.py,sha256=A6dO9r2E5uVFEgCPPK8F8aRqWoVhUf_v6-T0ro2KHyE,1399
+llmconnector/anthropic_client.py,sha256=nR7gZJ5fa_cJ334SkeNsBuwTkEAF0pF4C0ew-VuhSRY,12995
+llmconnector/client.py,sha256=3rNnHnIoYl2R9kiaZkHHqyf2gODvqwsPSFkhzLOOlTM,23141
+llmconnector/client_cli.py,sha256=8-C275ah4VrYW1noiPr78p8BB-rf7utiMFYMbFLuUVc,11421
+llmconnector/gemini_client.py,sha256=XPjeCnXLkmAPrhqw0GOsK9qGX7j6JYJOCiIQNxa8FJY,31484
+llmconnector/grok_client.py,sha256=oHqY6ooeuCSAGhkPpUprAzbXxmdLlnI-Gk8XDCvWW_0,10986
+llmconnector/openai_client.py,sha256=wIx-yUmbjg60jRHbJTjid9qr6O-d-L9ghPKKTOOHIv0,16266
+llmconnector/py.typed,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+llmconnector/types.py,sha256=7YvUHFY-pYAKL2YlwVJh0_Qe_SQNHDdV3TlaLzJe9oY,1644
+llmconnector/utils.py,sha256=iUzjnSINn5cX2Jq3E0CIjMUR_yBLblHCvCcB8NuXUiM,1970
+ccs_llmconnector-1.1.4.dist-info/METADATA,sha256=6ZzmSaWS4CmnsvjmA-ZKF704NDRlpMsF_7gniHIk6tc,17001
+ccs_llmconnector-1.1.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ccs_llmconnector-1.1.4.dist-info/entry_points.txt,sha256=eFvLY3nHAG_QhaKlemhhK7echfezW0KiMdSNMZOStLc,60
+ccs_llmconnector-1.1.4.dist-info/top_level.txt,sha256=Doer7TAUsN8UXQfPHPNsuBXVNCz2uV-Q0v4t4fwv_MM,13
+ccs_llmconnector-1.1.4.dist-info/RECORD,,

{ccs_llmconnector-1.1.2.dist-info → ccs_llmconnector-1.1.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

llmconnector/__init__.py

@@ -2,27 +2,29 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
-
-from .client import LLMClient
-from .types import ImageInput, Message, MessageSequence
-
-if TYPE_CHECKING:
-    from .anthropic_client import AnthropicClient
-    from .gemini_client import GeminiClient
-    from .grok_client import GrokClient
-    from .openai_client import OpenAIResponsesClient
-
-__all__ = [
-    "LLMClient",
-    "OpenAIResponsesClient",
-    "GeminiClient",
-    "AnthropicClient",
-    "GrokClient",
-    "ImageInput",
-    "Message",
-    "MessageSequence",
-]
+from typing import TYPE_CHECKING, Any
+
+from .client import LLMClient
+from .types import ImageInput, LLMResponse, Message, MessageSequence, TokenUsage
+
+if TYPE_CHECKING:
+    from .anthropic_client import AnthropicClient
+    from .gemini_client import GeminiClient
+    from .grok_client import GrokClient
+    from .openai_client import OpenAIResponsesClient
+
+__all__ = [
+    "LLMClient",
+    "OpenAIResponsesClient",
+    "GeminiClient",
+    "AnthropicClient",
+    "GrokClient",
+    "LLMResponse",
+    "ImageInput",
+    "Message",
+    "MessageSequence",
+    "TokenUsage",
+]
 
 
 def __getattr__(name: str) -> Any:

llmconnector/anthropic_client.py

@@ -2,53 +2,53 @@
 
 from __future__ import annotations
 
-import base64
-import mimetypes
-from pathlib import Path
-import logging
-from typing import Optional, Sequence
-from urllib.request import urlopen
-
-from anthropic import APIError, Anthropic
-
-from .types import ImageInput, MessageSequence, normalize_messages
-from .utils import clamp_retries, run_sync_in_thread, run_with_retries
-
-logger = logging.getLogger(__name__)
+import base64
+import mimetypes
+from pathlib import Path
+import logging
+from typing import Optional, Sequence
+from urllib.request import urlopen
+
+from anthropic import APIError, Anthropic
+
+from .types import ImageInput, MessageSequence, normalize_messages
+from .utils import clamp_retries, run_sync_in_thread, run_with_retries
+
+logger = logging.getLogger(__name__)
 
 
 class AnthropicClient:
     """Convenience wrapper around the Anthropic Messages API."""
 
-    def generate_response(
-        self,
-        *,
-        api_key: str,
-        prompt: Optional[str] = None,
-        model: str,
-        max_tokens: int = 32000,
-        reasoning_effort: Optional[str] = None,
-        images: Optional[Sequence[ImageInput]] = None,
-        messages: Optional[MessageSequence] = None,
-        request_id: Optional[str] = None,
-        timeout_s: Optional[float] = None,
-        max_retries: Optional[int] = None,
-        retry_backoff_s: float = 0.5,
-    ) -> str:
+    def generate_response(
+        self,
+        *,
+        api_key: str,
+        prompt: Optional[str] = None,
+        model: str,
+        max_tokens: int = 32000,
+        reasoning_effort: Optional[str] = None,
+        images: Optional[Sequence[ImageInput]] = None,
+        messages: Optional[MessageSequence] = None,
+        request_id: Optional[str] = None,
+        timeout_s: Optional[float] = None,
+        max_retries: Optional[int] = None,
+        retry_backoff_s: float = 0.5,
+    ) -> str:
         """Generate a response from the specified Anthropic model.
 
         Args:
             api_key: API key used to authenticate with Anthropic.
-            prompt: Natural-language instruction or query for the model.
-            model: Identifier of the Anthropic model to target (for example, ``"claude-3-5-sonnet-20241022"``).
-            max_tokens: Cap for tokens across the entire exchange, defaults to 32000.
-            reasoning_effort: Included for API parity; currently unused by the Anthropic SDK.
-            images: Optional collection of image references (local paths, URLs, or data URLs).
-            messages: Optional list of chat-style messages (role/content).
-            request_id: Optional request identifier for tracing/logging.
-            timeout_s: Optional request timeout in seconds.
-            max_retries: Optional retry count for transient failures.
-            retry_backoff_s: Base delay (seconds) for exponential backoff between retries.
+            prompt: Natural-language instruction or query for the model.
+            model: Identifier of the Anthropic model to target (for example, ``"claude-3-5-sonnet-20241022"``).
+            max_tokens: Cap for tokens across the entire exchange, defaults to 32000.
+            reasoning_effort: Included for API parity; currently unused by the Anthropic SDK.
+            images: Optional collection of image references (local paths, URLs, or data URLs).
+            messages: Optional list of chat-style messages (role/content).
+            request_id: Optional request identifier for tracing/logging.
+            timeout_s: Optional request timeout in seconds.
+            max_retries: Optional retry count for transient failures.
+            retry_backoff_s: Base delay (seconds) for exponential backoff between retries.
 
         Returns:
             The text output produced by the model.
@@ -57,240 +57,240 @@ class AnthropicClient:
             ValueError: If required arguments are missing or the request payload is empty.
             URLError: If an image URL cannot be retrieved.
             APIError: If the underlying Anthropic request fails.
-        """
-        if not api_key:
-            raise ValueError("api_key must be provided.")
-        if not prompt and not messages and not images:
-            raise ValueError("At least one of prompt, messages, or images must be provided.")
-        if not model:
-            raise ValueError("model must be provided.")
-
-        normalized_messages = normalize_messages(prompt=prompt, messages=messages)
-        message_payloads: list[dict] = []
-        for message in normalized_messages:
-            blocks: list[dict] = []
-            if message["content"]:
-                blocks.append({"type": "text", "text": message["content"]})
-            message_payloads.append({"role": message["role"], "content": blocks})
-
-        if images:
-            image_blocks = [self._to_image_block(image) for image in images]
-            target_index = next(
-                (
-                    index
-                    for index in range(len(message_payloads) - 1, -1, -1)
-                    if message_payloads[index]["role"] == "user"
-                ),
-                None,
-            )
-            if target_index is None:
-                message_payloads.append({"role": "user", "content": image_blocks})
-            else:
-                message_payloads[target_index]["content"].extend(image_blocks)
-
-        if not message_payloads or not any(msg["content"] for msg in message_payloads):
-            raise ValueError("No content provided for response generation.")
-
-        retry_count = clamp_retries(max_retries)
-
-        def _run_request() -> str:
-            client_kwargs = {"api_key": api_key}
-            if timeout_s is not None:
-                client_kwargs["timeout"] = timeout_s
-            client = Anthropic(**client_kwargs)
-
-            try:
-                response = client.messages.create(
-                    model=model,
-                    max_tokens=max_tokens,
-                    messages=message_payloads,
-                )
-            except Exception as exc:
-                logger.exception(
-                    "Anthropic messages.create failed: %s request_id=%s",
-                    exc,
-                    request_id,
-                )
-                raise
-
-            text_blocks: list[str] = []
-            for block in getattr(response, "content", []) or []:
-                if getattr(block, "type", None) == "text":
-                    text = getattr(block, "text", None)
-                    if text:
-                        text_blocks.append(text)
-
-            if text_blocks:
-                result_text = "".join(text_blocks)
-                logger.info(
-                    "Anthropic messages.create succeeded: model=%s images=%d text_len=%d request_id=%s",
-                    model,
-                    len(images or []),
-                    len(result_text or ""),
-                    request_id,
-                )
-                return result_text
-
-            # Treat successful calls without textual content as a successful, empty response
-            # rather than raising. This aligns with callers that handle empty outputs gracefully.
-            logger.info(
-                "Anthropic messages.create succeeded with no text: model=%s images=%d request_id=%s",
-                model,
-                len(images or []),
-                request_id,
-            )
-            return ""
-
-        return run_with_retries(
-            func=_run_request,
-            max_retries=retry_count,
-            retry_backoff_s=retry_backoff_s,
-            request_id=request_id,
-        )
-
-    async def async_generate_response(
-        self,
-        *,
-        api_key: str,
-        prompt: Optional[str] = None,
-        model: str,
-        max_tokens: int = 32000,
-        reasoning_effort: Optional[str] = None,
-        images: Optional[Sequence[ImageInput]] = None,
-        messages: Optional[MessageSequence] = None,
-        request_id: Optional[str] = None,
-        timeout_s: Optional[float] = None,
-        max_retries: Optional[int] = None,
-        retry_backoff_s: float = 0.5,
-    ) -> str:
-        return await run_sync_in_thread(
-            lambda: self.generate_response(
-                api_key=api_key,
-                prompt=prompt,
-                model=model,
-                max_tokens=max_tokens,
-                reasoning_effort=reasoning_effort,
-                images=images,
-                messages=messages,
-                request_id=request_id,
-                timeout_s=timeout_s,
-                max_retries=max_retries,
-                retry_backoff_s=retry_backoff_s,
-            )
-        )
-
-    def generate_image(
-        self,
-        *,
-        api_key: str,
-        prompt: str,
+        """
+        if not api_key:
+            raise ValueError("api_key must be provided.")
+        if not prompt and not messages and not images:
+            raise ValueError("At least one of prompt, messages, or images must be provided.")
+        if not model:
+            raise ValueError("model must be provided.")
+
+        normalized_messages = normalize_messages(prompt=prompt, messages=messages)
+        message_payloads: list[dict] = []
+        for message in normalized_messages:
+            blocks: list[dict] = []
+            if message["content"]:
+                blocks.append({"type": "text", "text": message["content"]})
+            message_payloads.append({"role": message["role"], "content": blocks})
+
+        if images:
+            image_blocks = [self._to_image_block(image) for image in images]
+            target_index = next(
+                (
+                    index
+                    for index in range(len(message_payloads) - 1, -1, -1)
+                    if message_payloads[index]["role"] == "user"
+                ),
+                None,
+            )
+            if target_index is None:
+                message_payloads.append({"role": "user", "content": image_blocks})
+            else:
+                message_payloads[target_index]["content"].extend(image_blocks)
+
+        if not message_payloads or not any(msg["content"] for msg in message_payloads):
+            raise ValueError("No content provided for response generation.")
+
+        retry_count = clamp_retries(max_retries)
+
+        def _run_request() -> str:
+            client_kwargs = {"api_key": api_key}
+            if timeout_s is not None:
+                client_kwargs["timeout"] = timeout_s
+            client = Anthropic(**client_kwargs)
+
+            try:
+                response = client.messages.create(
+                    model=model,
+                    max_tokens=max_tokens,
+                    messages=message_payloads,
+                )
+            except Exception as exc:
+                logger.exception(
+                    "Anthropic messages.create failed: %s request_id=%s",
+                    exc,
+                    request_id,
+                )
+                raise
+
+            text_blocks: list[str] = []
+            for block in getattr(response, "content", []) or []:
+                if getattr(block, "type", None) == "text":
+                    text = getattr(block, "text", None)
+                    if text:
+                        text_blocks.append(text)
+
+            if text_blocks:
+                result_text = "".join(text_blocks)
+                logger.info(
+                    "Anthropic messages.create succeeded: model=%s images=%d text_len=%d request_id=%s",
+                    model,
+                    len(images or []),
+                    len(result_text or ""),
+                    request_id,
+                )
+                return result_text
+
+            # Treat successful calls without textual content as a successful, empty response
+            # rather than raising. This aligns with callers that handle empty outputs gracefully.
+            logger.info(
+                "Anthropic messages.create succeeded with no text: model=%s images=%d request_id=%s",
+                model,
+                len(images or []),
+                request_id,
+            )
+            return ""
+
+        return run_with_retries(
+            func=_run_request,
+            max_retries=retry_count,
+            retry_backoff_s=retry_backoff_s,
+            request_id=request_id,
+        )
+
+    async def async_generate_response(
+        self,
+        *,
+        api_key: str,
+        prompt: Optional[str] = None,
+        model: str,
+        max_tokens: int = 32000,
+        reasoning_effort: Optional[str] = None,
+        images: Optional[Sequence[ImageInput]] = None,
+        messages: Optional[MessageSequence] = None,
+        request_id: Optional[str] = None,
+        timeout_s: Optional[float] = None,
+        max_retries: Optional[int] = None,
+        retry_backoff_s: float = 0.5,
+    ) -> str:
+        return await run_sync_in_thread(
+            lambda: self.generate_response(
+                api_key=api_key,
+                prompt=prompt,
+                model=model,
+                max_tokens=max_tokens,
+                reasoning_effort=reasoning_effort,
+                images=images,
+                messages=messages,
+                request_id=request_id,
+                timeout_s=timeout_s,
+                max_retries=max_retries,
+                retry_backoff_s=retry_backoff_s,
+            )
+        )
+
+    def generate_image(
+        self,
+        *,
+        api_key: str,
+        prompt: str,
         model: str,
         image_size: str = "2K",
         image: Optional[ImageInput] = None,
     ) -> bytes:
         """Generate an image using the Anthropic API.
 
-        Raises:
-            NotImplementedError: This method is not yet implemented for Anthropic.
-        """
-        raise NotImplementedError("Image generation is not implemented for Anthropic.")
-
-    async def async_generate_image(
-        self,
-        *,
-        api_key: str,
-        prompt: str,
-        model: str,
-        image_size: str = "2K",
-        image: Optional[ImageInput] = None,
-    ) -> bytes:
-        return await run_sync_in_thread(
-            lambda: self.generate_image(
-                api_key=api_key,
-                prompt=prompt,
-                model=model,
-                image_size=image_size,
-                image=image,
-            )
-        )
-
-    def list_models(
-        self,
-        *,
-        api_key: str,
-        request_id: Optional[str] = None,
-        timeout_s: Optional[float] = None,
-        max_retries: Optional[int] = None,
-        retry_backoff_s: float = 0.5,
-    ) -> list[dict[str, Optional[str]]]:
-        """Return the models available to the authenticated Anthropic account."""
-        if not api_key:
-            raise ValueError("api_key must be provided.")
-
-        retry_count = clamp_retries(max_retries)
-
-        def _run_request() -> list[dict[str, Optional[str]]]:
-            client_kwargs = {"api_key": api_key}
-            if timeout_s is not None:
-                client_kwargs["timeout"] = timeout_s
-            client = Anthropic(**client_kwargs)
-            models: list[dict[str, Optional[str]]] = []
-
-            try:
-                iterator = client.models.list()
-            except Exception as exc:
-                logger.exception(
-                    "Anthropic list models failed: %s request_id=%s",
-                    exc,
-                    request_id,
-                )
-                raise
-
-            for model in iterator:
-                model_id = getattr(model, "id", None)
-                if model_id is None and isinstance(model, dict):
-                    model_id = model.get("id")
-                if not model_id:
-                    continue
-
-                display_name = getattr(model, "display_name", None)
-                if display_name is None and isinstance(model, dict):
-                    display_name = model.get("display_name")
-
-                models.append({"id": model_id, "display_name": display_name})
-
-            logger.info(
-                "Anthropic list_models succeeded: count=%d request_id=%s",
-                len(models),
-                request_id,
-            )
-            return models
-
-        return run_with_retries(
-            func=_run_request,
-            max_retries=retry_count,
-            retry_backoff_s=retry_backoff_s,
-            request_id=request_id,
-        )
-
-    async def async_list_models(
-        self,
-        *,
-        api_key: str,
-        request_id: Optional[str] = None,
-        timeout_s: Optional[float] = None,
-        max_retries: Optional[int] = None,
-        retry_backoff_s: float = 0.5,
-    ) -> list[dict[str, Optional[str]]]:
-        return await run_sync_in_thread(
-            lambda: self.list_models(
-                api_key=api_key,
-                request_id=request_id,
-                timeout_s=timeout_s,
-                max_retries=max_retries,
-                retry_backoff_s=retry_backoff_s,
-            )
-        )
+        Raises:
+            NotImplementedError: This method is not yet implemented for Anthropic.
+        """
+        raise NotImplementedError("Image generation is not implemented for Anthropic.")
+
+    async def async_generate_image(
+        self,
+        *,
+        api_key: str,
+        prompt: str,
+        model: str,
+        image_size: str = "2K",
+        image: Optional[ImageInput] = None,
+    ) -> bytes:
+        return await run_sync_in_thread(
+            lambda: self.generate_image(
+                api_key=api_key,
+                prompt=prompt,
+                model=model,
+                image_size=image_size,
+                image=image,
+            )
+        )
+
+    def list_models(
+        self,
+        *,
+        api_key: str,
+        request_id: Optional[str] = None,
+        timeout_s: Optional[float] = None,
+        max_retries: Optional[int] = None,
+        retry_backoff_s: float = 0.5,
+    ) -> list[dict[str, Optional[str]]]:
+        """Return the models available to the authenticated Anthropic account."""
+        if not api_key:
+            raise ValueError("api_key must be provided.")
+
+        retry_count = clamp_retries(max_retries)
+
+        def _run_request() -> list[dict[str, Optional[str]]]:
+            client_kwargs = {"api_key": api_key}
+            if timeout_s is not None:
+                client_kwargs["timeout"] = timeout_s
+            client = Anthropic(**client_kwargs)
+            models: list[dict[str, Optional[str]]] = []
+
+            try:
+                iterator = client.models.list()
+            except Exception as exc:
+                logger.exception(
+                    "Anthropic list models failed: %s request_id=%s",
+                    exc,
+                    request_id,
+                )
+                raise
+
+            for model in iterator:
+                model_id = getattr(model, "id", None)
+                if model_id is None and isinstance(model, dict):
+                    model_id = model.get("id")
+                if not model_id:
+                    continue
+
+                display_name = getattr(model, "display_name", None)
+                if display_name is None and isinstance(model, dict):
+                    display_name = model.get("display_name")
+
+                models.append({"id": model_id, "display_name": display_name})
+
+            logger.info(
+                "Anthropic list_models succeeded: count=%d request_id=%s",
+                len(models),
+                request_id,
+            )
+            return models
+
+        return run_with_retries(
+            func=_run_request,
+            max_retries=retry_count,
+            retry_backoff_s=retry_backoff_s,
+            request_id=request_id,
+        )
+
+    async def async_list_models(
+        self,
+        *,
+        api_key: str,
+        request_id: Optional[str] = None,
+        timeout_s: Optional[float] = None,
+        max_retries: Optional[int] = None,
+        retry_backoff_s: float = 0.5,
+    ) -> list[dict[str, Optional[str]]]:
+        return await run_sync_in_thread(
+            lambda: self.list_models(
+                api_key=api_key,
+                request_id=request_id,
+                timeout_s=timeout_s,
+                max_retries=max_retries,
+                retry_backoff_s=retry_backoff_s,
+            )
+        )
 
     @staticmethod
     def _to_image_block(image: ImageInput) -> dict: