autobyteus 1.1.9__tar.gz → 1.2.0__tar.gz

{autobyteus-1.1.9 → autobyteus-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.1.9
+Version: 1.2.0
 Summary: Multi-Agent framework
 Home-page: https://github.com/AutoByteus/autobyteus
 Author: Ryan Zheng
@@ -16,14 +16,15 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp
 Requires-Dist: anthropic
-Requires-Dist: autobyteus-llm-client==1.1.3
 Requires-Dist: beautifulsoup4
 Requires-Dist: boto3
 Requires-Dist: botocore
 Requires-Dist: brui-core==1.0.9
 Requires-Dist: certifi==2025.4.26
+Requires-Dist: cryptography
 Requires-Dist: google-api-python-client
 Requires-Dist: google-genai==1.38.0
+Requires-Dist: httpx
 Requires-Dist: Jinja2
 Requires-Dist: mcp[cli]
 Requires-Dist: mistral_common

autobyteus-1.2.0/autobyteus/clients/__init__.py

@@ -0,0 +1,10 @@
+"""
+Client utilities for communicating with the Autobyteus LLM server.
+
+Consolidates the previously standalone autobyteus-llm-client package so the
+HTTP client can evolve alongside the rest of the framework.
+"""
+
+from .autobyteus_client import AutobyteusClient, CertificateError
+
+__all__ = ["AutobyteusClient", "CertificateError"]

autobyteus-1.2.0/autobyteus/clients/autobyteus_client.py

@@ -0,0 +1,318 @@
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any, AsyncGenerator, Dict, List, Optional, Union
+from urllib.parse import urljoin
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+class CertificateError(Exception):
+    """Custom exception for certificate-related errors."""
+
+
+class AutobyteusClient:
+    """Async + sync HTTP client for talking to an Autobyteus LLM server."""
+
+    DEFAULT_SERVER_URL = "https://api.autobyteus.com"
+    API_KEY_HEADER = "AUTOBYTEUS_API_KEY"
+    API_KEY_ENV_VAR = "AUTOBYTEUS_API_KEY"
+    SSL_CERT_FILE_ENV_VAR = "AUTOBYTEUS_SSL_CERT_FILE"
+
+    def __init__(self, server_url: Optional[str] = None):
+        """
+        Initialize the client.
+
+        Args:
+            server_url: Explicit server URL. Takes precedence over env vars.
+        """
+        self.server_url = server_url or os.getenv(
+            "AUTOBYTEUS_LLM_SERVER_URL", self.DEFAULT_SERVER_URL
+        )
+        self.api_key = os.getenv(self.API_KEY_ENV_VAR)
+
+        if not self.api_key:
+            raise ValueError(
+                f"{self.API_KEY_ENV_VAR} environment variable is required. "
+                "Please set it before initializing the client."
+            )
+
+        custom_cert_path_str = os.getenv(self.SSL_CERT_FILE_ENV_VAR)
+        verify_param: Union[str, bool, Path]
+
+        if custom_cert_path_str:
+            custom_cert_path = Path(custom_cert_path_str)
+            if not custom_cert_path.exists():
+                raise CertificateError(
+                    f"Custom SSL certificate file specified via {self.SSL_CERT_FILE_ENV_VAR} "
+                    f"not found at: {custom_cert_path}"
+                )
+            if not custom_cert_path.is_file():
+                raise CertificateError(
+                    f"Custom SSL certificate path specified via {self.SSL_CERT_FILE_ENV_VAR} "
+                    f"is not a file: {custom_cert_path}"
+                )
+            verify_param = str(custom_cert_path)
+            logger.info(
+                "Using custom SSL certificate file for TLS verification: %s. "
+                "This is the recommended secure method for servers with self-signed or "
+                "private CA certificates.",
+                verify_param,
+            )
+        else:
+            verify_param = False
+            logger.warning(
+                "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
+                "SECURITY WARNING: SSL certificate verification is DISABLED because the \n"
+                f"'{self.SSL_CERT_FILE_ENV_VAR}' environment variable is not set.\n"
+                "This configuration is INSECURE and makes the client vulnerable to \n"
+                "Man-in-the-Middle (MitM) attacks. It should ONLY be used for development \n"
+                "or testing in trusted environments with self-signed certificates if \n"
+                "providing the certificate path is not possible.\n"
+                "FOR PRODUCTION or secure environments with self-signed certificates, \n"
+                f"it is STRONGLY RECOMMENDED to set the '{self.SSL_CERT_FILE_ENV_VAR}' \n"
+                "environment variable to the path of the server's certificate (.pem file) \n"
+                "to enable proper TLS verification.\n"
+                "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+            )
+
+        timeout_config = httpx.Timeout(connect=10.0, read=None, write=None, pool=None)
+
+        try:
+            self.async_client = httpx.AsyncClient(
+                verify=verify_param,
+                headers={self.API_KEY_HEADER: self.api_key},
+                timeout=timeout_config,
+            )
+            self.sync_client = httpx.Client(
+                verify=verify_param,
+                headers={self.API_KEY_HEADER: self.api_key},
+                timeout=timeout_config,
+            )
+        except Exception as exc:
+            logger.error(
+                "Failed to initialize httpx client with SSL configuration (verify='%s'): %s",
+                verify_param,
+                exc,
+            )
+            raise RuntimeError(f"HTTP client initialization failed: {exc}") from exc
+
+        logger.info("Initialized Autobyteus client with server URL: %s", self.server_url)
+
+    async def get_available_llm_models(self) -> Dict[str, Any]:
+        """Async discovery of available LLM models."""
+        try:
+            response = await self.async_client.get(
+                urljoin(self.server_url, "/models/llm")
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Async LLM model fetch error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    def get_available_llm_models_sync(self) -> Dict[str, Any]:
+        """Synchronous discovery of available LLM models."""
+        try:
+            response = self.sync_client.get(urljoin(self.server_url, "/models/llm"))
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Sync LLM model fetch error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def get_available_image_models(self) -> Dict[str, Any]:
+        """Async discovery of available image models."""
+        try:
+            response = await self.async_client.get(
+                urljoin(self.server_url, "/models/image")
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Async image model fetch error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    def get_available_image_models_sync(self) -> Dict[str, Any]:
+        """Synchronous discovery of available image models."""
+        try:
+            response = self.sync_client.get(
+                urljoin(self.server_url, "/models/image")
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Sync image model fetch error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def get_available_audio_models(self) -> Dict[str, Any]:
+        """Async discovery of available audio models."""
+        try:
+            response = await self.async_client.get(
+                urljoin(self.server_url, "/models/audio")
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Async audio model fetch error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    def get_available_audio_models_sync(self) -> Dict[str, Any]:
+        """Synchronous discovery of available audio models."""
+        try:
+            response = self.sync_client.get(
+                urljoin(self.server_url, "/models/audio")
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Sync audio model fetch error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def send_message(
+        self,
+        conversation_id: str,
+        model_name: str,
+        user_message: str,
+        image_urls: Optional[List[str]] = None,
+        audio_urls: Optional[List[str]] = None,
+        video_urls: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """Send a message and get a response."""
+        try:
+            data = {
+                "conversation_id": conversation_id,
+                "model_name": model_name,
+                "user_message": user_message,
+                "image_urls": image_urls or [],
+                "audio_urls": audio_urls or [],
+                "video_urls": video_urls or [],
+            }
+            response = await self.async_client.post(
+                urljoin(self.server_url, "/send-message"),
+                json=data,
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Error sending message: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def stream_message(
+        self,
+        conversation_id: str,
+        model_name: str,
+        user_message: str,
+        image_urls: Optional[List[str]] = None,
+        audio_urls: Optional[List[str]] = None,
+        video_urls: Optional[List[str]] = None,
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        """Stream a message and get responses."""
+        try:
+            data = {
+                "conversation_id": conversation_id,
+                "model_name": model_name,
+                "user_message": user_message,
+                "image_urls": image_urls or [],
+                "audio_urls": audio_urls or [],
+                "video_urls": video_urls or [],
+            }
+
+            async with self.async_client.stream(
+                "POST",
+                urljoin(self.server_url, "/stream-message"),
+                json=data,
+            ) as response:
+                response.raise_for_status()
+
+                async for line in response.aiter_lines():
+                    if line.startswith("data: "):
+                        try:
+                            chunk = json.loads(line[6:])
+                            if "error" in chunk:
+                                raise RuntimeError(chunk["error"])
+                            yield chunk
+                        except json.JSONDecodeError as exc:
+                            logger.error("Failed to parse stream chunk: %s", exc)
+                            raise RuntimeError("Invalid stream response format") from exc
+
+        except httpx.HTTPError as exc:
+            logger.error("Stream error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def generate_image(
+        self,
+        model_name: str,
+        prompt: str,
+        input_image_urls: Optional[List[str]] = None,
+        mask_url: Optional[str] = None,
+        generation_config: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Generate or edit an image and return the server response."""
+        try:
+            data = {
+                "model_name": model_name,
+                "prompt": prompt,
+                "input_image_urls": input_image_urls or [],
+                "mask_url": mask_url,
+                "generation_config": generation_config or {},
+            }
+            response = await self.async_client.post(
+                urljoin(self.server_url, "/generate-image"),
+                json=data,
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Error generating image: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def generate_speech(
+        self,
+        model_name: str,
+        prompt: str,
+        generation_config: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Generate speech from text and return the server response."""
+        try:
+            data = {
+                "model_name": model_name,
+                "prompt": prompt,
+                "generation_config": generation_config or {},
+            }
+            response = await self.async_client.post(
+                urljoin(self.server_url, "/generate-speech"),
+                json=data,
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Error generating speech: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def cleanup(self, conversation_id: str) -> Dict[str, Any]:
+        """Clean up a conversation."""
+        try:
+            response = await self.async_client.post(
+                urljoin(self.server_url, "/cleanup"),
+                json={"conversation_id": conversation_id},
+            )
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPError as exc:
+            logger.error("Cleanup error: %s", exc)
+            raise RuntimeError(str(exc)) from exc
+
+    async def close(self) -> None:
+        """Close both HTTP clients."""
+        await self.async_client.aclose()
+        self.sync_client.close()
+
+    async def __aenter__(self) -> "AutobyteusClient":
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:  # type: ignore[override]
+        await self.close()

autobyteus-1.2.0/autobyteus/clients/cert_utils.py

@@ -0,0 +1,105 @@
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Optional, Union
+
+from cryptography import x509
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives import hashes
+
+logger = logging.getLogger(__name__)
+
+
+class CertificateError(Exception):
+    """Custom exception for certificate-related errors."""
+
+
+def get_certificate_info(cert_path: Union[str, Path]) -> Dict[str, object]:
+    """
+    Retrieve certificate information including fingerprint and validity window.
+    """
+    try:
+        cert_path = Path(cert_path)
+        cert_data = cert_path.read_bytes()
+        cert = x509.load_pem_x509_certificate(cert_data, default_backend())
+
+        cert_der = cert.fingerprint(hashes.SHA256())
+        fingerprint = ":".join(f"{byte:02X}" for byte in cert_der)
+
+        now = datetime.utcnow()
+        days_until_expiry = (cert.not_valid_after - now).days
+
+        return {
+            "subject": cert.subject.get_attributes_for_oid(x509.NameOID.COMMON_NAME)[
+                0
+            ].value,
+            "issuer": cert.issuer.get_attributes_for_oid(x509.NameOID.COMMON_NAME)[
+                0
+            ].value,
+            "valid_from": cert.not_valid_before,
+            "valid_until": cert.not_valid_after,
+            "fingerprint": fingerprint,
+            "is_valid": cert.not_valid_before < now < cert.not_valid_after,
+            "days_until_expiry": days_until_expiry,
+            "cert_data": cert_data,
+            "cert": cert,
+        }
+    except Exception as exc:  # pragma: no cover - defensive logging
+        raise CertificateError(f"Failed to get certificate info: {exc}") from exc
+
+
+def verify_certificate(
+    cert_path: Union[str, Path],
+    expected_fingerprint: Optional[str] = None,
+    warn_expiry_days: int = 30,
+) -> Dict[str, object]:
+    """
+    Verify the certificate's validity and optional fingerprint match.
+    """
+    try:
+        info = get_certificate_info(cert_path)
+
+        if not info["is_valid"]:
+            if datetime.utcnow() < info["valid_from"]:
+                raise CertificateError("Certificate is not yet valid")
+            raise CertificateError(
+                f"Certificate has expired on {info['valid_until'].strftime('%Y-%m-%d')}"
+            )
+
+        if expected_fingerprint:
+            expected = expected_fingerprint.replace(" ", "").upper()
+            actual = str(info["fingerprint"]).replace(" ", "")
+            if actual != expected:
+                raise CertificateError(
+                    "Certificate fingerprint mismatch. "
+                    f"Expected: {expected}\nGot: {actual}"
+                )
+            logger.info("Certificate fingerprint verified successfully")
+        else:
+            logger.warning(
+                "Certificate fingerprint verification skipped. "
+                "Set AUTOBYTEUS_CERT_FINGERPRINT to enable this security feature. "
+                "Current certificate fingerprint: %s",
+                info["fingerprint"],
+            )
+
+        logger.info(
+            "Certificate valid from %s to %s",
+            info["valid_from"],
+            info["valid_until"],
+        )
+        logger.info("Certificate fingerprint (SHA256): %s", info["fingerprint"])
+        logger.info("Certificate subject: %s", info["subject"])
+
+        if info["days_until_expiry"] <= warn_expiry_days:
+            logger.warning(
+                "Certificate will expire in %s days on %s",
+                info["days_until_expiry"],
+                info["valid_until"].strftime("%Y-%m-%d"),
+            )
+
+        return info
+    except CertificateError:
+        raise
+    except Exception as exc:  # pragma: no cover - defensive logging
+        raise CertificateError(f"Certificate verification failed: {exc}") from exc

autobyteus-1.2.0/autobyteus/clients/certificates/cert.pem

@@ -0,0 +1,34 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----

{autobyteus-1.1.9 → autobyteus-1.2.0}/autobyteus/llm/api/autobyteus_llm.py

@@ -5,7 +5,7 @@ from autobyteus.llm.utils.llm_config import LLMConfig
 from autobyteus.llm.utils.token_usage import TokenUsage
 from autobyteus.llm.utils.response_types import CompleteResponse, ChunkResponse
 from autobyteus.llm.user_message import LLMUserMessage
-from autobyteus_llm_client.client import AutobyteusClient
+from autobyteus.clients import AutobyteusClient
 import logging
 import uuid
 

autobyteus-1.2.0/autobyteus/llm/api/zhipu_llm.py

@@ -0,0 +1,26 @@
+import logging
+from typing import Optional
+from autobyteus.llm.models import LLMModel
+from autobyteus.llm.utils.llm_config import LLMConfig
+from autobyteus.llm.api.openai_compatible_llm import OpenAICompatibleLLM
+
+logger = logging.getLogger(__name__)
+
+class ZhipuLLM(OpenAICompatibleLLM):
+    def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
+        # Provide defaults if not specified
+        if model is None:
+            model = LLMModel['glm-4.6']
+        if llm_config is None:
+            llm_config = LLMConfig()
+            
+        super().__init__(
+            model=model,
+            llm_config=llm_config,
+            api_key_env_var="ZHIPU_API_KEY",
+            base_url="https://open.bigmodel.cn/api/paas/v4/"
+        )
+        logger.info(f"ZhipuLLM initialized with model: {self.model}")
+
+    async def cleanup(self):
+        await super().cleanup()

{autobyteus-1.1.9 → autobyteus-1.2.0}/autobyteus/llm/autobyteus_provider.py

@@ -7,7 +7,7 @@ from typing import Dict, Any, TYPE_CHECKING, List, Optional
 import os
 import logging
 from urllib.parse import urlparse
-from autobyteus_llm_client import AutobyteusClient
+from autobyteus.clients import AutobyteusClient
 
 if TYPE_CHECKING:
     from autobyteus.llm.llm_factory import LLMFactory

{autobyteus-1.1.9 → autobyteus-1.2.0}/autobyteus/llm/llm_factory.py

@@ -18,6 +18,7 @@ from autobyteus.llm.api.gemini_llm import GeminiLLM
 from autobyteus.llm.api.grok_llm import GrokLLM
 from autobyteus.llm.api.kimi_llm import KimiLLM
 from autobyteus.llm.api.qwen_llm import QwenLLM
+from autobyteus.llm.api.zhipu_llm import ZhipuLLM
 from autobyteus.llm.ollama_provider import OllamaModelProvider
 from autobyteus.llm.lmstudio_provider import LMStudioModelProvider
 from autobyteus.utils.singleton import SingletonMeta
@@ -360,6 +361,28 @@ class LLMFactory(metaclass=SingletonMeta):
                     )
                 )
             ),
+            # ZHIPU Provider Models
+            LLMModel(
+                name="glm-4.6",
+                value="glm-4.6",
+                provider=LLMProvider.ZHIPU,
+                llm_class=ZhipuLLM,
+                canonical_name="glm-4.6",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(13.8, 13.8)
+                )
+            ),
+            LLMModel(
+                name="glm-4.6-thinking",
+                value="glm-4.6",
+                provider=LLMProvider.ZHIPU,
+                llm_class=ZhipuLLM,
+                canonical_name="glm-4.6-thinking",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(13.8, 13.8),
+                    extra_params={ "extra_body": { "thinking": { "type": "enabled" } } }
+                )
+            ),
         ]
         for model in supported_models:
             LLMFactory.register_model(model)

{autobyteus-1.1.9 → autobyteus-1.2.0}/autobyteus/llm/ollama_provider_resolver.py

@@ -19,6 +19,7 @@ class OllamaProviderResolver:
         (['mistral'], LLMProvider.MISTRAL),
         (['deepseek'], LLMProvider.DEEPSEEK),
         (['qwen'], LLMProvider.QWEN),
+        (['glm'], LLMProvider.ZHIPU),
     ]
 
     @staticmethod

{autobyteus-1.1.9 → autobyteus-1.2.0}/autobyteus/llm/providers.py

@@ -15,3 +15,4 @@ class LLMProvider(Enum):
     KIMI = "KIMI"
     QWEN = "QWEN"
     LMSTUDIO = "LMSTUDIO"
+    ZHIPU = "ZHIPU"

{autobyteus-1.1.9 → autobyteus-1.2.0}/autobyteus/llm/token_counter/token_counter_factory.py

@@ -4,6 +4,7 @@ from autobyteus.llm.token_counter.claude_token_counter import ClaudeTokenCounter
 from autobyteus.llm.token_counter.mistral_token_counter import MistralTokenCounter
 from autobyteus.llm.token_counter.deepseek_token_counter import DeepSeekTokenCounter
 from autobyteus.llm.token_counter.kimi_token_counter import KimiTokenCounter
+from autobyteus.llm.token_counter.zhipu_token_counter import ZhipuTokenCounter
 from autobyteus.llm.token_counter.base_token_counter import BaseTokenCounter
 from autobyteus.llm.models import LLMModel
 from autobyteus.llm.providers import LLMProvider
@@ -42,6 +43,8 @@ def get_token_counter(model: LLMModel, llm: 'BaseLLM') -> BaseTokenCounter:
         return OpenAITokenCounter(model, llm)
     elif model.provider == LLMProvider.GEMINI:
         return OpenAITokenCounter(model, llm)
+    elif model.provider == LLMProvider.ZHIPU:
+        return ZhipuTokenCounter(model, llm)
     else:
         # For models that do not have a specialized counter, raise a NotImplementedError
         raise NotImplementedError(f"No token counter available for model {model.value}")

autobyteus-1.2.0/autobyteus/llm/token_counter/zhipu_token_counter.py

@@ -0,0 +1,24 @@
+from typing import TYPE_CHECKING
+from autobyteus.llm.token_counter.openai_token_counter import OpenAITokenCounter
+from autobyteus.llm.models import LLMModel
+
+if TYPE_CHECKING:
+    from autobyteus.llm.base_llm import BaseLLM
+
+class ZhipuTokenCounter(OpenAITokenCounter):
+    """
+    Token counter for Zhipu models. Uses the same token counting implementation as OpenAI.
+    
+    This implementation inherits from OpenAITokenCounter as Zhipu uses a similar tokenization
+    approach as OpenAI's models.
+    """
+    
+    def __init__(self, model: LLMModel, llm: 'BaseLLM' = None):
+        """
+        Initialize the Zhipu token counter.
+        
+        Args:
+            model (LLMModel): The Zhipu model to count tokens for.
+            llm (BaseLLM, optional): The LLM instance. Defaults to None.
+        """
+        super().__init__(model, llm)

{autobyteus-1.1.9 → autobyteus-1.2.0}/autobyteus/multimedia/audio/api/autobyteus_audio_client.py

@@ -1,6 +1,6 @@
 import logging
 from typing import Optional, List, Dict, Any, TYPE_CHECKING
-from autobyteus_llm_client import AutobyteusClient
+from autobyteus.clients import AutobyteusClient
 from autobyteus.multimedia.audio.base_audio_client import BaseAudioClient
 from autobyteus.multimedia.utils.response_types import SpeechGenerationResponse
 

{autobyteus-1.1.9 → autobyteus-1.2.0}/autobyteus/multimedia/audio/autobyteus_audio_provider.py

@@ -3,7 +3,7 @@ from typing import List
 import os
 from urllib.parse import urlparse
 
-from autobyteus_llm_client import AutobyteusClient
+from autobyteus.clients import AutobyteusClient
 from autobyteus.multimedia.audio.api.autobyteus_audio_client import AutobyteusAudioClient
 from autobyteus.multimedia.audio.audio_model import AudioModel
 from autobyteus.multimedia.providers import MultimediaProvider

{autobyteus-1.1.9 → autobyteus-1.2.0}/autobyteus/multimedia/image/api/autobyteus_image_client.py

@@ -1,6 +1,6 @@
 import logging
 from typing import Optional, List, Dict, Any, TYPE_CHECKING
-from autobyteus_llm_client import AutobyteusClient
+from autobyteus.clients import AutobyteusClient
 from autobyteus.multimedia.image.base_image_client import BaseImageClient
 from autobyteus.multimedia.utils.response_types import ImageGenerationResponse
 

{autobyteus-1.1.9 → autobyteus-1.2.0}/autobyteus/multimedia/image/autobyteus_image_provider.py

@@ -3,7 +3,7 @@ from typing import Dict, Any, List
 import os
 from urllib.parse import urlparse
 
-from autobyteus_llm_client import AutobyteusClient
+from autobyteus.clients import AutobyteusClient
 from autobyteus.multimedia.image.api.autobyteus_image_client import AutobyteusImageClient
 from autobyteus.multimedia.image.image_model import ImageModel
 from autobyteus.multimedia.providers import MultimediaProvider