amd-gaia 0.15.0__py3-none-any.whl → 0.15.2__py3-none-any.whl

gaia/llm/providers/claude.py

@@ -0,0 +1,108 @@
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""Claude provider - no embeddings support."""
+
+from typing import Iterator, Optional, Union
+
+try:
+    import anthropic
+except ImportError:
+    anthropic = None  # type: ignore
+
+from ..base_client import LLMClient
+
+
+class ClaudeProvider(LLMClient):
+    """Claude (Anthropic) provider."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        model: str = "claude-3-5-sonnet-20241022",
+        system_prompt: Optional[str] = None,
+        **_kwargs,
+    ):
+        if anthropic is None:
+            raise ImportError(
+                "anthropic package is required for ClaudeProvider. "
+                "Install it with: pip install anthropic"
+            )
+
+        self._client = anthropic.Anthropic(api_key=api_key)
+        self._model = model
+        self._system_prompt = system_prompt
+
+    @property
+    def provider_name(self) -> str:
+        return "Claude"
+
+    def generate(
+        self,
+        prompt: str,
+        model: str | None = None,
+        stream: bool = False,
+        **kwargs,
+    ) -> Union[str, Iterator[str]]:
+        return self.chat(
+            [{"role": "user", "content": prompt}],
+            model=model,
+            stream=stream,
+            **kwargs,
+        )
+
+    def chat(
+        self,
+        messages: list[dict],
+        model: str | None = None,
+        stream: bool = False,
+        **kwargs,
+    ) -> Union[str, Iterator[str]]:
+        # Build parameters for Anthropic messages.create
+        params = {
+            "model": model or self._model,
+            "messages": messages,
+            "stream": stream,
+            **kwargs,
+        }
+        # Claude API requires system prompt as separate parameter, not in messages
+        if self._system_prompt:
+            params["system"] = self._system_prompt
+
+        response = self._client.messages.create(**params)
+        if stream:
+            return self._handle_stream(response)
+        return response.content[0].text
+
+    # embed() inherited from ABC - raises NotSupportedError
+
+    def vision(self, images: list[bytes], prompt: str, **kwargs) -> str:
+        import base64
+
+        # Claude supports vision via messages
+        image_b64 = base64.b64encode(images[0]).decode()
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "image",
+                        "source": {
+                            "type": "base64",
+                            "media_type": "image/jpeg",
+                            "data": image_b64,
+                        },
+                    },
+                    {"type": "text", "text": prompt},
+                ],
+            }
+        ]
+        return self.chat(messages, **kwargs)
+
+    # get_performance_stats() inherited from ABC - raises NotSupportedError
+    # load_model() inherited from ABC - raises NotSupportedError
+    # unload_model() inherited from ABC - raises NotSupportedError
+
+    def _handle_stream(self, response) -> Iterator[str]:
+        for chunk in response:
+            if hasattr(chunk, "delta") and hasattr(chunk.delta, "text"):
+                yield chunk.delta.text

gaia/llm/providers/lemonade.py

@@ -0,0 +1,118 @@
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""Lemonade provider - supports ALL methods."""
+
+from typing import Iterator, Optional, Union
+
+from ..base_client import LLMClient
+from ..lemonade_client import DEFAULT_MODEL_NAME, LemonadeClient
+
+
+class LemonadeProvider(LLMClient):
+    """Lemonade provider - local AMD-optimized inference."""
+
+    def __init__(
+        self,
+        model: Optional[str] = None,
+        base_url: Optional[str] = None,
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        system_prompt: Optional[str] = None,
+        **kwargs,
+    ):
+        # Build kwargs for LemonadeClient, only including non-None values
+        backend_kwargs = {}
+        if model is not None:
+            backend_kwargs["model"] = model
+        if base_url is not None:
+            backend_kwargs["base_url"] = base_url
+        if host is not None:
+            backend_kwargs["host"] = host
+        if port is not None:
+            backend_kwargs["port"] = port
+        backend_kwargs.update(kwargs)
+
+        self._backend = LemonadeClient(**backend_kwargs)
+        self._model = model
+        self._system_prompt = system_prompt
+
+    @property
+    def provider_name(self) -> str:
+        return "Lemonade"
+
+    def generate(
+        self,
+        prompt: str,
+        model: str | None = None,
+        stream: bool = False,
+        **kwargs,
+    ) -> Union[str, Iterator[str]]:
+        # Use chat endpoint (completions endpoint not available in Lemonade v9.1+)
+        return self.chat(
+            [{"role": "user", "content": prompt}],
+            model=model,
+            stream=stream,
+            **kwargs,
+        )
+
+    def chat(
+        self,
+        messages: list[dict],
+        model: str | None = None,
+        stream: bool = False,
+        **kwargs,
+    ) -> Union[str, Iterator[str]]:
+        # Use provided model, instance model, or default CPU model
+        effective_model = model or self._model or DEFAULT_MODEL_NAME
+
+        # Prepend system prompt if set
+        if self._system_prompt:
+            messages = [{"role": "system", "content": self._system_prompt}] + list(
+                messages
+            )
+
+        # Default to low temperature for deterministic responses (matches old LLMClient behavior)
+        kwargs.setdefault("temperature", 0.1)
+
+        response = self._backend.chat_completions(
+            model=effective_model, messages=messages, stream=stream, **kwargs
+        )
+        if stream:
+            return self._handle_stream(response)
+        return response["choices"][0]["message"]["content"]
+
+    def embed(self, texts: list[str], **kwargs) -> list[list[float]]:
+        response = self._backend.embeddings(texts, **kwargs)
+        return [item["embedding"] for item in response["data"]]
+
+    def vision(self, images: list[bytes], prompt: str, **kwargs) -> str:
+        # Delegate to VLMClient
+        from ..vlm_client import VLMClient
+
+        vlm = VLMClient(base_url=self._backend.base_url)
+        return vlm.extract_from_image(images[0], prompt=prompt)
+
+    def get_performance_stats(self) -> dict:
+        return self._backend.get_stats() or {}
+
+    def load_model(self, model_name: str, **kwargs) -> None:
+        self._backend.load_model(model_name, **kwargs)
+        self._model = model_name
+
+    def unload_model(self) -> None:
+        self._backend.unload_model()
+
+    def _extract_text(self, response: dict) -> str:
+        return response["choices"][0]["text"]
+
+    def _handle_stream(self, response) -> Iterator[str]:
+        for chunk in response:
+            if "choices" in chunk and chunk["choices"]:
+                delta = chunk["choices"][0].get("delta", {})
+                content = delta.get("content")
+                if content:
+                    yield content
+                elif "text" in chunk["choices"][0]:
+                    text = chunk["choices"][0]["text"]
+                    if text:
+                        yield text

gaia/llm/providers/openai_provider.py

@@ -0,0 +1,79 @@
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""OpenAI provider - no vision support."""
+
+from typing import Iterator, Optional, Union
+
+from ..base_client import LLMClient
+
+
+class OpenAIProvider(LLMClient):
+    """OpenAI (OpenAI API) provider."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        model: str = "gpt-4o",
+        system_prompt: Optional[str] = None,
+        **_kwargs,
+    ):
+        import openai
+
+        self._client = openai.OpenAI(api_key=api_key)
+        self._model = model
+        self._system_prompt = system_prompt
+
+    @property
+    def provider_name(self) -> str:
+        return "OpenAI"
+
+    def generate(
+        self,
+        prompt: str,
+        model: str | None = None,
+        stream: bool = False,
+        **kwargs,
+    ) -> Union[str, Iterator[str]]:
+        # OpenAI doesn't have a separate completions endpoint for chat models
+        return self.chat(
+            [{"role": "user", "content": prompt}],
+            model=model,
+            stream=stream,
+            **kwargs,
+        )
+
+    def chat(
+        self,
+        messages: list[dict],
+        model: str | None = None,
+        stream: bool = False,
+        **kwargs,
+    ) -> Union[str, Iterator[str]]:
+        # Prepend system prompt if set
+        if self._system_prompt:
+            messages = [{"role": "system", "content": self._system_prompt}] + list(
+                messages
+            )
+
+        response = self._client.chat.completions.create(
+            model=model or self._model, messages=messages, stream=stream, **kwargs
+        )
+        if stream:
+            return self._handle_stream(response)
+        return response.choices[0].message.content
+
+    def embed(
+        self, texts: list[str], model: str = "text-embedding-3-small", **kwargs
+    ) -> list[list[float]]:
+        response = self._client.embeddings.create(model=model, input=texts, **kwargs)
+        return [item.embedding for item in response.data]
+
+    # vision() inherited from ABC - raises NotSupportedError
+    # get_performance_stats() inherited from ABC - raises NotSupportedError
+    # load_model() inherited from ABC - raises NotSupportedError
+    # unload_model() inherited from ABC - raises NotSupportedError
+
+    def _handle_stream(self, response) -> Iterator[str]:
+        for chunk in response:
+            if chunk.choices and chunk.choices[0].delta.content:
+                yield chunk.choices[0].delta.content