ccs-llmconnector 1.0.4__py3-none-any.whl → 1.0.5__py3-none-any.whl

llmconnector/grok_client.py

@@ -1,170 +1,186 @@
-"""Thin wrapper around the xAI Grok chat API via the xai-sdk package."""
-
-from __future__ import annotations
-
-import base64
-import mimetypes
-from pathlib import Path
-import logging
-from typing import Optional, Sequence, Union
-
-from xai_sdk import Client
-from xai_sdk.chat import image as chat_image
-from xai_sdk.chat import user
-
-ImageInput = Union[str, Path]
-logger = logging.getLogger(__name__)
-
-
-class GrokClient:
-    """Convenience wrapper around the xAI Grok chat API."""
-
-    def generate_response(
-        self,
-        *,
-        api_key: str,
-        prompt: str,
-        model: str,
-        max_tokens: int = 32000,
-        reasoning_effort: Optional[str] = None,
-        images: Optional[Sequence[ImageInput]] = None,
-    ) -> str:
-        """Generate a response from the specified Grok model.
-
-        Args:
-            api_key: API key used to authenticate with xAI.
-            prompt: Natural-language instruction or query for the model.
-            model: Identifier of the Grok model to target (for example, ``"grok-3"``).
-            max_tokens: Cap for tokens in the generated response, defaults to 32000.
-            reasoning_effort: Optional hint for reasoning-focused models (``"low"`` or ``"high"``).
-            images: Optional collection of image references (local paths, URLs, or data URLs).
-
-        Returns:
-            The text output produced by the model.
-
-        Raises:
-            ValueError: If required arguments are missing or the request payload is empty.
-            RuntimeError: If the Grok response does not contain any textual content.
-        """
-        if not api_key:
-            raise ValueError("api_key must be provided.")
-        if not prompt and not images:
-            raise ValueError("At least one of prompt or images must be provided.")
-        if not model:
-            raise ValueError("model must be provided.")
-
-        message_parts = []
-        if prompt:
-            message_parts.append(prompt)
-
-        if images:
-            for image in images:
-                message_parts.append(chat_image(self._to_image_url(image)))
-
-        if not message_parts:
-            raise ValueError("No content provided for response generation.")
-
-        grok_client = Client(api_key=api_key)
-
-        create_kwargs = {
-            "model": model,
-            "max_tokens": max_tokens,
-            "messages": [user(*message_parts)],
-        }
-
-        normalized_effort = (reasoning_effort or "").strip().lower()
-        if normalized_effort in {"low", "high"}:
-            create_kwargs["reasoning_effort"] = normalized_effort
-
-        try:
-            chat = grok_client.chat.create(**create_kwargs)
-            response = chat.sample()
-        except Exception as exc:
-            logger.exception("xAI Grok chat request failed: %s", exc)
-            raise
-
-        content = getattr(response, "content", None)
-        if content:
-            logger.info(
-                "xAI chat succeeded: model=%s images=%d text_len=%d",
-                model,
-                len(images or []),
-                len(content or ""),
-            )
-            return content
-
-        reasoning_content = getattr(response, "reasoning_content", None)
-        if reasoning_content:
-            logger.info(
-                "xAI chat succeeded (reasoning): model=%s images=%d text_len=%d",
-                model,
-                len(images or []),
-                len(reasoning_content or ""),
-            )
-            return reasoning_content
-
-        # 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(
-            "xAI chat succeeded with no text: model=%s images=%d",
-            model,
-            len(images or []),
-        )
-        return ""
-
-    def list_models(self, *, api_key: str) -> list[dict[str, Optional[str]]]:
-        """Return the Grok language models available to the authenticated account."""
-        if not api_key:
-            raise ValueError("api_key must be provided.")
-
-        grok_client = Client(api_key=api_key)
-        models: list[dict[str, Optional[str]]] = []
-
-        try:
-            iterator = grok_client.models.list_language_models()
-        except Exception as exc:
-            logger.exception("xAI list language models failed: %s", exc)
-            raise
-
-        for model in iterator:
-            model_id = getattr(model, "name", None)
-            if not model_id:
-                continue
-
-            aliases = getattr(model, "aliases", None)
-            display_name: Optional[str] = None
-            if aliases:
-                try:
-                    display_name = next(iter(aliases)) or None
-                except (StopIteration, TypeError):
-                    display_name = None
-
-            models.append(
-                {
-                    "id": model_id,
-                    "display_name": display_name,
-                }
-            )
-
-        logger.info("xAI list_language_models succeeded: count=%d", len(models))
-        return models
-
-    @staticmethod
-    def _to_image_url(image: ImageInput) -> str:
-        """Convert an image reference into a URL or data URL suitable for the xAI SDK."""
-        if isinstance(image, Path):
-            return _encode_image_path(image)
-
-        if image.startswith(("http://", "https://", "data:")):
-            return image
-
-        return _encode_image_path(Path(image))
-
-
-def _encode_image_path(path: Path) -> str:
-    """Generate a data URL for the provided image path."""
-    expanded = path.expanduser()
-    data = expanded.read_bytes()
-    mime_type = mimetypes.guess_type(expanded.name)[0] or "application/octet-stream"
-    encoded = base64.b64encode(data).decode("utf-8")
-    return f"data:{mime_type};base64,{encoded}"
+"""Thin wrapper around the xAI Grok chat API via the xai-sdk package."""
+
+from __future__ import annotations
+
+import base64
+import mimetypes
+from pathlib import Path
+import logging
+from typing import Optional, Sequence, Union
+
+from xai_sdk import Client
+from xai_sdk.chat import image as chat_image
+from xai_sdk.chat import user
+
+ImageInput = Union[str, Path]
+logger = logging.getLogger(__name__)
+
+
+class GrokClient:
+    """Convenience wrapper around the xAI Grok chat API."""
+
+    def generate_response(
+        self,
+        *,
+        api_key: str,
+        prompt: str,
+        model: str,
+        max_tokens: int = 32000,
+        reasoning_effort: Optional[str] = None,
+        images: Optional[Sequence[ImageInput]] = None,
+    ) -> str:
+        """Generate a response from the specified Grok model.
+
+        Args:
+            api_key: API key used to authenticate with xAI.
+            prompt: Natural-language instruction or query for the model.
+            model: Identifier of the Grok model to target (for example, ``"grok-3"``).
+            max_tokens: Cap for tokens in the generated response, defaults to 32000.
+            reasoning_effort: Optional hint for reasoning-focused models (``"low"`` or ``"high"``).
+            images: Optional collection of image references (local paths, URLs, or data URLs).
+
+        Returns:
+            The text output produced by the model.
+
+        Raises:
+            ValueError: If required arguments are missing or the request payload is empty.
+            RuntimeError: If the Grok response does not contain any textual content.
+        """
+        if not api_key:
+            raise ValueError("api_key must be provided.")
+        if not prompt and not images:
+            raise ValueError("At least one of prompt or images must be provided.")
+        if not model:
+            raise ValueError("model must be provided.")
+
+        message_parts = []
+        if prompt:
+            message_parts.append(prompt)
+
+        if images:
+            for image in images:
+                message_parts.append(chat_image(self._to_image_url(image)))
+
+        if not message_parts:
+            raise ValueError("No content provided for response generation.")
+
+        grok_client = Client(api_key=api_key)
+
+        create_kwargs = {
+            "model": model,
+            "max_tokens": max_tokens,
+            "messages": [user(*message_parts)],
+        }
+
+        normalized_effort = (reasoning_effort or "").strip().lower()
+        if normalized_effort in {"low", "high"}:
+            create_kwargs["reasoning_effort"] = normalized_effort
+
+        try:
+            chat = grok_client.chat.create(**create_kwargs)
+            response = chat.sample()
+        except Exception as exc:
+            logger.exception("xAI Grok chat request failed: %s", exc)
+            raise
+
+        content = getattr(response, "content", None)
+        if content:
+            logger.info(
+                "xAI chat succeeded: model=%s images=%d text_len=%d",
+                model,
+                len(images or []),
+                len(content or ""),
+            )
+            return content
+
+        reasoning_content = getattr(response, "reasoning_content", None)
+        if reasoning_content:
+            logger.info(
+                "xAI chat succeeded (reasoning): model=%s images=%d text_len=%d",
+                model,
+                len(images or []),
+                len(reasoning_content or ""),
+            )
+            return reasoning_content
+
+        # 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(
+            "xAI chat succeeded with no text: model=%s images=%d",
+            model,
+            len(images or []),
+        )
+        return ""
+
+    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 Grok API.
+
+        Raises:
+            NotImplementedError: This method is not yet implemented for Grok.
+        """
+        raise NotImplementedError("Image generation is not implemented for Grok.")
+
+    def list_models(self, *, api_key: str) -> list[dict[str, Optional[str]]]:
+        """Return the Grok language models available to the authenticated account."""
+        if not api_key:
+            raise ValueError("api_key must be provided.")
+
+        grok_client = Client(api_key=api_key)
+        models: list[dict[str, Optional[str]]] = []
+
+        try:
+            iterator = grok_client.models.list_language_models()
+        except Exception as exc:
+            logger.exception("xAI list language models failed: %s", exc)
+            raise
+
+        for model in iterator:
+            model_id = getattr(model, "name", None)
+            if not model_id:
+                continue
+
+            aliases = getattr(model, "aliases", None)
+            display_name: Optional[str] = None
+            if aliases:
+                try:
+                    display_name = next(iter(aliases)) or None
+                except (StopIteration, TypeError):
+                    display_name = None
+
+            models.append(
+                {
+                    "id": model_id,
+                    "display_name": display_name,
+                }
+            )
+
+        logger.info("xAI list_language_models succeeded: count=%d", len(models))
+        return models
+
+    @staticmethod
+    def _to_image_url(image: ImageInput) -> str:
+        """Convert an image reference into a URL or data URL suitable for the xAI SDK."""
+        if isinstance(image, Path):
+            return _encode_image_path(image)
+
+        if image.startswith(("http://", "https://", "data:")):
+            return image
+
+        return _encode_image_path(Path(image))
+
+
+def _encode_image_path(path: Path) -> str:
+    """Generate a data URL for the provided image path."""
+    expanded = path.expanduser()
+    data = expanded.read_bytes()
+    mime_type = mimetypes.guess_type(expanded.name)[0] or "application/octet-stream"
+    encoded = base64.b64encode(data).decode("utf-8")
+    return f"data:{mime_type};base64,{encoded}"

llmconnector/openai_client.py

@@ -4,26 +4,26 @@ from __future__ import annotations
 
 import base64
 import mimetypes
-from pathlib import Path
-import logging
-from typing import Optional, Sequence, Union
-
-from openai import OpenAI
-
-try:
-    from openai import APIError as OpenAIError  # type: ignore
-except ImportError:  # pragma: no cover - fallback for older SDKs
-    from openai.error import OpenAIError  # type: ignore
-
-ImageInput = Union[str, Path]
-logger = logging.getLogger(__name__)
-
-
-class OpenAIResponsesClient:
-    """Convenience wrapper around the OpenAI Responses API."""
-
-    def generate_response(
-        self,
+from pathlib import Path
+import logging
+from typing import Optional, Sequence, Union
+
+from openai import OpenAI
+
+try:
+    from openai import APIError as OpenAIError  # type: ignore
+except ImportError:  # pragma: no cover - fallback for older SDKs
+    from openai.error import OpenAIError  # type: ignore
+
+ImageInput = Union[str, Path]
+logger = logging.getLogger(__name__)
+
+
+class OpenAIResponsesClient:
+    """Convenience wrapper around the OpenAI Responses API."""
+
+    def generate_response(
+        self,
         *,
         api_key: str,
         prompt: str,
@@ -83,24 +83,24 @@ class OpenAIResponsesClient:
         if reasoning_effort:
             request_payload["reasoning"] = {"effort": reasoning_effort}
 
-        try:
-            response = client.responses.create(**request_payload)
-        except Exception as exc:  # Log and re-raise to preserve default behavior
-            logger.exception("OpenAI Responses API request failed: %s", exc)
-            raise
-
-        output_text = response.output_text
-        logger.info(
-            "OpenAI generate_response succeeded: model=%s images=%d text_len=%d",
-            model,
-            len(images or []),
-            len(output_text or ""),
-        )
-        return output_text
-
-    @staticmethod
-    def _to_image_block(image: ImageInput) -> dict:
-        """Convert an image reference into an OpenAI Responses API block."""
+        try:
+            response = client.responses.create(**request_payload)
+        except Exception as exc:  # Log and re-raise to preserve default behavior
+            logger.exception("OpenAI Responses API request failed: %s", exc)
+            raise
+
+        output_text = response.output_text
+        logger.info(
+            "OpenAI generate_response succeeded: model=%s images=%d text_len=%d",
+            model,
+            len(images or []),
+            len(output_text or ""),
+        )
+        return output_text
+
+    @staticmethod
+    def _to_image_block(image: ImageInput) -> dict:
+        """Convert an image reference into an OpenAI Responses API block."""
         if isinstance(image, Path):
             return {
                 "type": "input_image",
@@ -113,41 +113,57 @@ class OpenAIResponsesClient:
                 "image_url": image,
             }
 
-        return {
-            "type": "input_image",
-            "image_url": _encode_image_path(Path(image)),
-        }
-
-    def list_models(self, *, api_key: str) -> list[dict[str, Optional[str]]]:
-        """Return the models available to the authenticated OpenAI account."""
-        if not api_key:
-            raise ValueError("api_key must be provided.")
-
-        client = OpenAI(api_key=api_key)
-        try:
-            response = client.models.list()
-        except Exception as exc:
-            logger.exception("OpenAI list models failed: %s", exc)
-            raise
-        data = getattr(response, "data", []) or []
-
-        models: list[dict[str, Optional[str]]] = []
-        for model in data:
-            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("OpenAI list_models succeeded: count=%d", len(models))
-        return models
-
+        return {
+            "type": "input_image",
+            "image_url": _encode_image_path(Path(image)),
+        }
+
+    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 OpenAI API.
+
+        Raises:
+            NotImplementedError: This method is not yet implemented for OpenAI.
+        """
+        raise NotImplementedError("Image generation is not implemented for OpenAI.")
+
+    def list_models(self, *, api_key: str) -> list[dict[str, Optional[str]]]:
+        """Return the models available to the authenticated OpenAI account."""
+        if not api_key:
+            raise ValueError("api_key must be provided.")
+
+        client = OpenAI(api_key=api_key)
+        try:
+            response = client.models.list()
+        except Exception as exc:
+            logger.exception("OpenAI list models failed: %s", exc)
+            raise
+        data = getattr(response, "data", []) or []
+
+        models: list[dict[str, Optional[str]]] = []
+        for model in data:
+            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("OpenAI list_models succeeded: count=%d", len(models))
+        return models
+
 
 def _encode_image_path(path: Path) -> str:
     """Generate a data URL for the provided image path."""

llmconnector/py.typed

@@ -1 +1 @@
-
+

ccs_llmconnector-1.0.4.dist-info/RECORD

@@ -1,14 +0,0 @@
-ccs_llmconnector-1.0.4.dist-info/licenses/LICENSE,sha256=YYl_gt0O2aJW046pklgKWlVVZZpFcTIOsycrs69ltn4,1061
-llmconnector/__init__.py,sha256=SCCVGnaj8aFeE5ugvgf2bGmCLt29R__hoRu0qKhJA4c,1174
-llmconnector/anthropic_client.py,sha256=BoRoIqdgKKico_7u7T-jDybhta3dlEYMTL8FX1SfEDM,7197
-llmconnector/client.py,sha256=SVn-afiwjdnFnlDflN-WiGK1wdFyazh5wSmUTtRWQmU,4834
-llmconnector/client_cli.py,sha256=ncEkQ5xcoPnfnnDYaFKbpf6imR9uDBqlLFxS9EA1_7s,10335
-llmconnector/gemini_client.py,sha256=GDcx3KfYHWA4qlTHRqPQ_wGk_HL8wIRWB-qHT4ZHC0k,8060
-llmconnector/grok_client.py,sha256=lv-syTmqcgpLsLf6VVsPnghos3lR9YvPIuNv-Iy7SAo,5823
-llmconnector/openai_client.py,sha256=ECugkVsKNWaV_Xl3suY9XhagSAyCP1AwKP1mXtUGmDk,5402
-llmconnector/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-ccs_llmconnector-1.0.4.dist-info/METADATA,sha256=ym56hl73mswU1qhD5n9lDsaEh2SIEdpE1MvuAvdXQec,14051
-ccs_llmconnector-1.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ccs_llmconnector-1.0.4.dist-info/entry_points.txt,sha256=eFvLY3nHAG_QhaKlemhhK7echfezW0KiMdSNMZOStLc,60
-ccs_llmconnector-1.0.4.dist-info/top_level.txt,sha256=Doer7TAUsN8UXQfPHPNsuBXVNCz2uV-Q0v4t4fwv_MM,13
-ccs_llmconnector-1.0.4.dist-info/RECORD,,