amigo_sdk 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

amigo_sdk/__init__.py

@@ -1 +1,8 @@
-__version__ = "0.8.0"
+__version__ = "0.9.0"
+from .sdk_client import AmigoClient, AsyncAmigoClient
+
+__all__ = [
+    "__version__",
+    "AmigoClient",
+    "AsyncAmigoClient",
+]

amigo_sdk/_retry_utils.py

@@ -0,0 +1,70 @@
+import datetime as dt
+import random
+from email.utils import parsedate_to_datetime
+from typing import Optional
+
+DEFAULT_RETRYABLE_STATUS: set[int] = {429, 500, 502, 503, 504}
+
+
+def parse_retry_after_seconds(retry_after: Optional[str]) -> float | None:
+    """Parse Retry-After header into seconds.
+
+    Supports both numeric seconds and HTTP-date formats. Returns None when
+    header is missing or invalid.
+    """
+    if not retry_after:
+        return None
+    # Numeric seconds
+    try:
+        seconds = float(retry_after)
+        return max(0.0, seconds)
+    except Exception:
+        pass
+    # HTTP-date format
+    try:
+        target_dt = parsedate_to_datetime(retry_after)
+        if target_dt is None:
+            return None
+        if target_dt.tzinfo is None:
+            target_dt = target_dt.replace(tzinfo=dt.UTC)
+        now = dt.datetime.now(dt.UTC)
+        delta_seconds = (target_dt - now).total_seconds()
+        return max(0.0, delta_seconds)
+    except Exception:
+        return None
+
+
+def is_retryable_response(
+    method: str,
+    status_code: int,
+    headers: dict,
+    retry_on_methods: set[str],
+    retry_on_status: set[int],
+) -> bool:
+    """Determine if the response is retryable under our policy.
+
+    Special case: allow POST retry only on 429 when Retry-After is present.
+    """
+    method_upper = method.upper()
+    if method_upper == "POST" and status_code == 429 and headers.get("Retry-After"):
+        return True
+    return method_upper in retry_on_methods and status_code in retry_on_status
+
+
+def compute_retry_delay_seconds(
+    attempt: int,
+    backoff_base: float,
+    max_delay_seconds: float,
+    retry_after_header: Optional[str],
+) -> float:
+    """Compute delay for a given retry attempt.
+
+    If Retry-After is present, honor it (clamped by max). Otherwise, use
+    exponential backoff with full jitter.
+    """
+    ra_seconds = parse_retry_after_seconds(retry_after_header)
+    if ra_seconds is not None:
+        return min(max_delay_seconds, ra_seconds)
+    window = backoff_base * (2 ** (attempt - 1))
+    window = min(window, max_delay_seconds)
+    return random.uniform(0.0, window)

amigo_sdk/auth.py

@@ -5,26 +5,44 @@ from amigo_sdk.errors import AuthenticationError
 from amigo_sdk.generated.model import UserSignInWithApiKeyResponse
 
 
-async def sign_in_with_api_key(
-    cfg: AmigoConfig,
+def _signin_url_headers(cfg: AmigoConfig) -> tuple[str, dict[str, str]]:
+    url = f"{cfg.base_url}/v1/{cfg.organization_id}/user/signin_with_api_key"
+    headers = {
+        "x-api-key": cfg.api_key,
+        "x-api-key-id": cfg.api_key_id,
+        "x-user-id": cfg.user_id,
+    }
+    return url, headers
+
+
+def _parse_signin_response_text(
+    response: httpx.Response,
 ) -> UserSignInWithApiKeyResponse:
-    """
-    Sign in with API key.
-    """
-    async with httpx.AsyncClient() as client:
-        url = f"{cfg.base_url}/v1/{cfg.organization_id}/user/signin_with_api_key"
-        headers = {
-            "x-api-key": cfg.api_key,
-            "x-api-key-id": cfg.api_key_id,
-            "x-user-id": cfg.user_id,
-        }
+    try:
+        return UserSignInWithApiKeyResponse.model_validate_json(response.text)
+    except Exception as e:
+        raise AuthenticationError(f"Invalid response format: {e}") from e
+
+
+def sign_in_with_api_key(cfg: AmigoConfig) -> UserSignInWithApiKeyResponse:
+    """Sign in with API key (sync)."""
+    url, headers = _signin_url_headers(cfg)
+    with httpx.Client() as client:
         try:
-            response = await client.post(url, headers=headers)
+            response = client.post(url, headers=headers)
             response.raise_for_status()
         except httpx.HTTPStatusError as e:
             raise AuthenticationError(f"Sign in with API key failed: {e}") from e
+        return _parse_signin_response_text(response)
 
+
+async def sign_in_with_api_key_async(cfg: AmigoConfig) -> UserSignInWithApiKeyResponse:
+    """Sign in with API key (async)."""
+    url, headers = _signin_url_headers(cfg)
+    async with httpx.AsyncClient() as client:
         try:
-            return UserSignInWithApiKeyResponse.model_validate_json(response.text)
-        except Exception as e:
-            raise AuthenticationError(f"Invalid response format: {e}") from e
+            response = await client.post(url, headers=headers)
+            response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            raise AuthenticationError(f"Sign in with API key failed: {e}") from e
+        return _parse_signin_response_text(response)

amigo_sdk/generated/model.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
 #   filename:  <stdin>
-#   timestamp: 2025-08-21T18:39:42+00:00
+#   timestamp: 2025-08-25T20:27:06+00:00
 
 from __future__ import annotations
 
@@ -8330,8 +8330,6 @@ class LLMConfigOutput(BaseModel):
 
 class LLMLoadBalancingSetType(Enum):
     o4_mini_2025_04_16 = 'o4-mini-2025-04-16'
-    gpt_4_1_2025_04_14 = 'gpt-4.1-2025-04-14'
-    gpt_4_1_mini_2025_04_14 = 'gpt-4.1-mini-2025-04-14'
     gpt_5_2025_08_07 = 'gpt-5-2025-08-07'
     gpt_5_mini_2025_08_07 = 'gpt-5-mini-2025-08-07'
     gpt_5_nano_2025_08_07 = 'gpt-5-nano-2025-08-07'
@@ -8341,8 +8339,6 @@ class LLMLoadBalancingSetType(Enum):
 
 class LLMType(Enum):
     openai_o4_mini_2025_04_16 = 'openai_o4-mini-2025-04-16'
-    openai_gpt_4_1_2025_04_14 = 'openai_gpt-4.1-2025-04-14'
-    openai_gpt_4_1_mini_2025_04_14 = 'openai_gpt-4.1-mini-2025-04-14'
     openai_gpt_5_2025_08_07 = 'openai_gpt-5-2025-08-07'
     openai_gpt_5_mini_2025_08_07 = 'openai_gpt-5-mini-2025-08-07'
     openai_gpt_5_nano_2025_08_07 = 'openai_gpt-5-nano-2025-08-07'
@@ -11646,7 +11642,7 @@ class GetConversationMessagesParametersQuery(BaseModel):
         [], description='The IDs of the messages to retrieve.', title='Id'
     )
     message_type: Optional[List[MessageType]] = Field(
-        ['agent-message', 'user-message', 'external-event'],
+        ['agent-message', 'external-event', 'user-message'],
         description='The type of messages to retrieve.',
         title='Message Type',
     )

amigo_sdk/http_client.py

@@ -1,13 +1,15 @@
 import asyncio
 import datetime as dt
 import random
-from collections.abc import AsyncIterator
+import time
+from collections.abc import AsyncIterator, Iterator
+from dataclasses import dataclass
 from email.utils import parsedate_to_datetime
 from typing import Any, Optional
 
 import httpx
 
-from amigo_sdk.auth import sign_in_with_api_key
+from amigo_sdk.auth import sign_in_with_api_key, sign_in_with_api_key_async
 from amigo_sdk.config import AmigoConfig
 from amigo_sdk.errors import (
     AuthenticationError,
@@ -16,48 +18,33 @@ from amigo_sdk.errors import (
 )
 from amigo_sdk.generated.model import UserSignInWithApiKeyResponse
 
+# -----------------------------
+# Shared helpers and structures
+# -----------------------------
 
-class AmigoHttpClient:
-    def __init__(
-        self,
-        cfg: AmigoConfig,
-        *,
-        retry_max_attempts: int = 3,
-        retry_backoff_base: float = 0.25,
-        retry_max_delay_seconds: float = 30.0,
-        retry_on_status: set[int] | None = None,
-        retry_on_methods: set[str] | None = None,
-        **httpx_kwargs: Any,
-    ) -> None:
-        self._cfg = cfg
-        self._token: Optional[UserSignInWithApiKeyResponse] = None
-        self._client = httpx.AsyncClient(
-            base_url=cfg.base_url,
-            **httpx_kwargs,
-        )
-        # Retry configuration
-        self._retry_max_attempts = max(1, retry_max_attempts)
-        self._retry_backoff_base = retry_backoff_base
-        self._retry_max_delay_seconds = max(0.0, retry_max_delay_seconds)
-        self._retry_on_status = retry_on_status or {408, 429, 500, 502, 503, 504}
-        # Default to GET only; POST is handled specially for 429 + Retry-After
-        self._retry_on_methods = {m.upper() for m in (retry_on_methods or {"GET"})}
 
-    def _is_retryable_method(self, method: str) -> bool:
-        return method.upper() in self._retry_on_methods
+@dataclass
+class _RetryConfig:
+    max_attempts: int
+    backoff_base: float
+    max_delay_seconds: float
+    on_status: set[int]
+    on_methods: set[str]
+
+    def is_retryable_method(self, method: str) -> bool:
+        return method.upper() in self.on_methods
 
-    def _is_retryable_response(self, method: str, resp: httpx.Response) -> bool:
+    def is_retryable_response(self, method: str, resp: httpx.Response) -> bool:
         status = resp.status_code
-        # Allow POST retry only for 429 when Retry-After header is present
         if (
             method.upper() == "POST"
             and status == 429
             and resp.headers.get("Retry-After")
         ):
             return True
-        return self._is_retryable_method(method) and status in self._retry_on_status
+        return self.is_retryable_method(method) and status in self.on_status
 
-    def _parse_retry_after_seconds(self, resp: httpx.Response) -> float | None:
+    def parse_retry_after_seconds(self, resp: httpx.Response) -> float | None:
         retry_after = resp.headers.get("Retry-After")
         if not retry_after:
             return None
@@ -76,28 +63,94 @@ class AmigoHttpClient:
                 target_dt = target_dt.replace(tzinfo=dt.UTC)
             now = dt.datetime.now(dt.UTC)
             delta_seconds = (target_dt - now).total_seconds()
+            # Round to milliseconds to avoid borderline off-by-epsilon in tests
+            delta_seconds = round(delta_seconds, 3)
             return max(0.0, delta_seconds)
         except Exception:
             return None
 
-    def _retry_delay_seconds(self, attempt: int, resp: httpx.Response | None) -> float:
+    def retry_delay_seconds(self, attempt: int, resp: httpx.Response | None) -> float:
         # Honor Retry-After when present (numeric or HTTP-date), clamped by max delay
         if resp is not None:
-            ra_seconds = self._parse_retry_after_seconds(resp)
+            ra_seconds = self.parse_retry_after_seconds(resp)
             if ra_seconds is not None:
-                return min(self._retry_max_delay_seconds, ra_seconds)
+                return min(self.max_delay_seconds, ra_seconds)
         # Exponential backoff with full jitter: U(0, min(cap, base * 2^(attempt-1)))
-        window = self._retry_backoff_base * (2 ** (attempt - 1))
-        window = min(window, self._retry_max_delay_seconds)
+        window = self.backoff_base * (2 ** (attempt - 1))
+        window = min(window, self.max_delay_seconds)
         return random.uniform(0.0, window)
 
+
+def _should_refresh_token(token: Optional[UserSignInWithApiKeyResponse]) -> bool:
+    if not token:
+        return True
+    return dt.datetime.now(dt.UTC) > token.expires_at - dt.timedelta(minutes=5)
+
+
+async def _raise_status_with_body_async(resp: httpx.Response) -> None:
+    if 200 <= resp.status_code < 300:
+        return
+    try:
+        await resp.aread()
+    except Exception:
+        pass
+    if hasattr(resp, "is_success"):
+        raise_for_status(resp)
+    error_class = get_error_class_for_status_code(getattr(resp, "status_code", 0))
+    raise error_class(
+        f"HTTP {getattr(resp, 'status_code', 'unknown')} error",
+        status_code=getattr(resp, "status_code", None),
+    )
+
+
+def _raise_status_with_body_sync(resp: httpx.Response) -> None:
+    if 200 <= resp.status_code < 300:
+        return
+    try:
+        _ = resp.text
+    except Exception:
+        pass
+    if hasattr(resp, "is_success"):
+        raise_for_status(resp)
+    error_class = get_error_class_for_status_code(getattr(resp, "status_code", 0))
+    raise error_class(
+        f"HTTP {getattr(resp, 'status_code', 'unknown')} error",
+        status_code=getattr(resp, "status_code", None),
+    )
+
+
+class AmigoAsyncHttpClient:
+    def __init__(
+        self,
+        cfg: AmigoConfig,
+        *,
+        retry_max_attempts: int = 3,
+        retry_backoff_base: float = 0.25,
+        retry_max_delay_seconds: float = 30.0,
+        retry_on_status: set[int] | None = None,
+        retry_on_methods: set[str] | None = None,
+        **httpx_kwargs: Any,
+    ) -> None:
+        self._cfg = cfg
+        self._token: Optional[UserSignInWithApiKeyResponse] = None
+        self._client = httpx.AsyncClient(
+            base_url=cfg.base_url,
+            **httpx_kwargs,
+        )
+        # Retry configuration
+        self._retry_cfg = _RetryConfig(
+            max(1, retry_max_attempts),
+            retry_backoff_base,
+            max(0.0, retry_max_delay_seconds),
+            retry_on_status or {408, 429, 500, 502, 503, 504},
+            {m.upper() for m in (retry_on_methods or {"GET"})},
+        )
+
     async def _ensure_token(self) -> str:
         """Fetch or refresh bearer token ~5 min before expiry."""
-        if not self._token or dt.datetime.now(
-            dt.UTC
-        ) > self._token.expires_at - dt.timedelta(minutes=5):
+        if _should_refresh_token(self._token):
             try:
-                self._token = await sign_in_with_api_key(self._cfg)
+                self._token = await sign_in_with_api_key_async(self._cfg)
             except Exception as e:
                 raise AuthenticationError(
                     "API-key exchange failed",
@@ -127,20 +180,20 @@ class AmigoHttpClient:
             except (httpx.TimeoutException, httpx.TransportError):
                 # Retry only if method is allowed (e.g., GET); POST not retried for transport/timeouts
                 if (
-                    not self._is_retryable_method(method)
-                    or attempt >= self._retry_max_attempts
+                    not self._retry_cfg.is_retryable_method(method)
+                    or attempt >= self._retry_cfg.max_attempts
                 ):
                     raise
-                await asyncio.sleep(self._retry_delay_seconds(attempt, None))
+                await asyncio.sleep(self._retry_cfg.retry_delay_seconds(attempt, None))
                 attempt += 1
                 continue
 
             # Retry on configured HTTP status codes
             if (
-                self._is_retryable_response(method, resp)
-                and attempt < self._retry_max_attempts
+                self._retry_cfg.is_retryable_response(method, resp)
+                and attempt < self._retry_cfg.max_attempts
             ):
-                await asyncio.sleep(self._retry_delay_seconds(attempt, resp))
+                await asyncio.sleep(self._retry_cfg.retry_delay_seconds(attempt, resp))
                 attempt += 1
                 continue
 
@@ -166,29 +219,8 @@ class AmigoHttpClient:
         headers["Authorization"] = f"Bearer {await self._ensure_token()}"
         headers.setdefault("Accept", "application/x-ndjson")
 
-        async def _raise_status_with_body(resp: httpx.Response) -> None:
-            """Ensure response body is buffered, then raise mapped error with details."""
-            if 200 <= resp.status_code < 300:
-                return
-            # Fully buffer the body so raise_for_status() can extract JSON/text safely
-            try:
-                await resp.aread()
-            except Exception:
-                pass
-            # If this is a real httpx.Response, use our rich raise_for_status
-            if hasattr(resp, "is_success"):
-                raise_for_status(resp)
-            # Otherwise, fall back to lightweight error mapping used in tests' mock responses
-            error_class = get_error_class_for_status_code(
-                getattr(resp, "status_code", 0)
-            )
-            raise error_class(
-                f"HTTP {getattr(resp, 'status_code', 'unknown')} error",
-                status_code=getattr(resp, "status_code", None),
-            )
-
         async def _yield_from_response(resp: httpx.Response) -> AsyncIterator[str]:
-            await _raise_status_with_body(resp)
+            await _raise_status_with_body_async(resp)
             if abort_event and abort_event.is_set():
                 return
             async for line in resp.aiter_lines():
@@ -221,8 +253,127 @@ class AmigoHttpClient:
         await self._client.aclose()
 
     # async-context-manager sugar
-    async def __aenter__(self):  # → async with AmigoHTTPClient(...) as http:
+    async def __aenter__(self):  # → async with AmigoAsyncHttpClient(...) as http:
         return self
 
     async def __aexit__(self, *_):
         await self.aclose()
+
+
+class AmigoHttpClient:
+    def __init__(
+        self,
+        cfg: AmigoConfig,
+        *,
+        retry_max_attempts: int = 3,
+        retry_backoff_base: float = 0.25,
+        retry_max_delay_seconds: float = 30.0,
+        retry_on_status: set[int] | None = None,
+        retry_on_methods: set[str] | None = None,
+        **httpx_kwargs: Any,
+    ) -> None:
+        self._cfg = cfg
+        self._token: Optional[UserSignInWithApiKeyResponse] = None
+        self._client = httpx.Client(base_url=cfg.base_url, **httpx_kwargs)
+        # Retry configuration
+        self._retry_cfg = _RetryConfig(
+            max(1, retry_max_attempts),
+            retry_backoff_base,
+            max(0.0, retry_max_delay_seconds),
+            retry_on_status or {408, 429, 500, 502, 503, 504},
+            {m.upper() for m in (retry_on_methods or {"GET"})},
+        )
+
+    def _ensure_token(self) -> str:
+        if _should_refresh_token(self._token):
+            try:
+                self._token = sign_in_with_api_key(self._cfg)
+            except Exception as e:
+                raise AuthenticationError("API-key exchange failed") from e
+        return self._token.id_token
+
+    def request(self, method: str, path: str, **kwargs) -> httpx.Response:
+        kwargs.setdefault("headers", {})
+        attempt = 1
+
+        while True:
+            kwargs["headers"]["Authorization"] = f"Bearer {self._ensure_token()}"
+
+            resp: httpx.Response | None = None
+            try:
+                resp = self._client.request(method, path, **kwargs)
+                if resp.status_code == 401:
+                    self._token = None
+                    kwargs["headers"]["Authorization"] = (
+                        f"Bearer {self._ensure_token()}"
+                    )
+                    resp = self._client.request(method, path, **kwargs)
+
+            except (httpx.TimeoutException, httpx.TransportError):
+                if (
+                    not self._retry_cfg.is_retryable_method(method)
+                ) or attempt >= self._retry_cfg.max_attempts:
+                    raise
+                time.sleep(self._retry_cfg.retry_delay_seconds(attempt, None))
+                attempt += 1
+                continue
+
+            if (
+                self._retry_cfg.is_retryable_response(method, resp)
+                and attempt < self._retry_cfg.max_attempts
+            ):
+                time.sleep(self._retry_cfg.retry_delay_seconds(attempt, resp))
+                attempt += 1
+                continue
+
+            raise_for_status(resp)
+            return resp
+
+    def stream_lines(
+        self,
+        method: str,
+        path: str,
+        abort_flag: list[bool] | None = None,
+        **kwargs,
+    ) -> Iterator[str]:
+        kwargs.setdefault("headers", {})
+        headers = kwargs["headers"]
+        headers["Authorization"] = f"Bearer {self._ensure_token()}"
+        headers.setdefault("Accept", "application/x-ndjson")
+
+        def _yield_from_response(resp: httpx.Response) -> Iterator[str]:
+            _raise_status_with_body_sync(resp)
+            if abort_flag and abort_flag[0]:
+                return
+            for line in resp.iter_lines():
+                if abort_flag and abort_flag[0]:
+                    return
+                line_stripped = (line or "").strip()
+                if not line_stripped:
+                    continue
+                yield line_stripped
+
+        if abort_flag and abort_flag[0]:
+            return iter(())
+        with self._client.stream(method, path, **kwargs) as resp:
+            if resp.status_code == 401:
+                self._token = None
+                headers["Authorization"] = f"Bearer {self._ensure_token()}"
+                if abort_flag and abort_flag[0]:
+                    return iter(())
+                with self._client.stream(method, path, **kwargs) as retry_resp:
+                    for ln in _yield_from_response(retry_resp):
+                        yield ln
+                return
+
+            for ln in _yield_from_response(resp):
+                yield ln
+
+    def aclose(self) -> None:
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.aclose()

amigo_sdk/resources/conversation.py

@@ -1,5 +1,5 @@
 import asyncio
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Iterator
 from datetime import datetime
 from typing import Any, Literal
 
@@ -21,7 +21,7 @@ from amigo_sdk.generated.model import (
     GetConversationsParametersQuery,
     InteractWithConversationParametersQuery,
 )
-from amigo_sdk.http_client import AmigoHttpClient
+from amigo_sdk.http_client import AmigoAsyncHttpClient, AmigoHttpClient
 
 
 class GetMessageSourceResponse(BaseModel):
@@ -35,10 +35,10 @@ class GetMessageSourceResponse(BaseModel):
     content_type: Literal["audio/mpeg", "audio/wav"]
 
 
-class ConversationResource:
+class AsyncConversationResource:
     """Conversation resource for Amigo API operations."""
 
-    def __init__(self, http_client: AmigoHttpClient, organization_id: str) -> None:
+    def __init__(self, http_client: AmigoAsyncHttpClient, organization_id: str) -> None:
         self._http = http_client
         self._organization_id = organization_id
 
@@ -206,3 +206,155 @@ class ConversationResource:
         return ConversationGenerateConversationStarterResponse.model_validate_json(
             response.text
         )
+
+
+class ConversationResource:
+    """Conversation resource for synchronous operations."""
+
+    def __init__(self, http_client: AmigoHttpClient, organization_id: str) -> None:
+        self._http = http_client
+        self._organization_id = organization_id
+
+    def create_conversation(
+        self,
+        body: ConversationCreateConversationRequest,
+        params: CreateConversationParametersQuery,
+        abort_flag: list[bool] | None = None,
+    ) -> Iterator[ConversationCreateConversationResponse]:
+        def _iter():
+            for line in self._http.stream_lines(
+                "POST",
+                f"/v1/{self._organization_id}/conversation/",
+                params=params.model_dump(mode="json", exclude_none=True),
+                json=body.model_dump(mode="json", exclude_none=True),
+                headers={"Accept": "application/x-ndjson"},
+                abort_flag=abort_flag,
+            ):
+                yield ConversationCreateConversationResponse.model_validate_json(line)
+
+        return _iter()
+
+    def interact_with_conversation(
+        self,
+        conversation_id: str,
+        params: InteractWithConversationParametersQuery,
+        abort_flag: list[bool] | None = None,
+        *,
+        text_message: str | None = None,
+        audio_bytes: bytes | None = None,
+        audio_content_type: Literal["audio/mpeg", "audio/wav"] | None = None,
+    ) -> Iterator[ConversationInteractWithConversationResponse]:
+        def _iter():
+            request_kwargs: dict[str, Any] = {
+                "params": params.model_dump(mode="json", exclude_none=True),
+                "headers": {"Accept": "application/x-ndjson"},
+                "abort_flag": abort_flag,
+            }
+            req_format = getattr(params, "request_format", None)
+            if req_format == Format.text:
+                if text_message is None:
+                    raise ValueError(
+                        "text_message is required when request_format is 'text'"
+                    )
+                text_bytes = text_message.encode("utf-8")
+                request_kwargs["files"] = {
+                    "recorded_message": (
+                        "message.txt",
+                        text_bytes,
+                        "text/plain; charset=utf-8",
+                    )
+                }
+            elif req_format == Format.voice:
+                if audio_bytes is None or audio_content_type is None:
+                    raise ValueError(
+                        "audio_bytes and audio_content_type are required when request_format is 'voice'"
+                    )
+                request_kwargs["content"] = audio_bytes
+                request_kwargs.setdefault("headers", {})
+                request_kwargs["headers"]["Content-Type"] = audio_content_type
+            else:
+                raise ValueError("Unsupported or missing request_format in params")
+
+            for line in self._http.stream_lines(
+                "POST",
+                f"/v1/{self._organization_id}/conversation/{conversation_id}/interact",
+                **request_kwargs,
+            ):
+                yield ConversationInteractWithConversationResponse.model_validate_json(
+                    line
+                )
+
+        return _iter()
+
+    def finish_conversation(self, conversation_id: str) -> None:
+        self._http.request(
+            "POST",
+            f"/v1/{self._organization_id}/conversation/{conversation_id}/finish/",
+        )
+
+    def get_conversations(
+        self, params: GetConversationsParametersQuery
+    ) -> ConversationGetConversationsResponse:
+        response = self._http.request(
+            "GET",
+            f"/v1/{self._organization_id}/conversation/",
+            params=params.model_dump(mode="json", exclude_none=True),
+        )
+        return ConversationGetConversationsResponse.model_validate_json(response.text)
+
+    def get_conversation_messages(
+        self, conversation_id: str, params: GetConversationMessagesParametersQuery
+    ) -> ConversationGetConversationMessagesResponse:
+        response = self._http.request(
+            "GET",
+            f"/v1/{self._organization_id}/conversation/{conversation_id}/messages/",
+            params=params.model_dump(
+                mode="json", exclude_none=True, exclude_defaults=True
+            ),
+        )
+        return ConversationGetConversationMessagesResponse.model_validate_json(
+            response.text
+        )
+
+    def recommend_responses_for_interaction(
+        self, conversation_id: str, interaction_id: str
+    ) -> ConversationRecommendResponsesForInteractionResponse:
+        response = self._http.request(
+            "GET",
+            f"/v1/{self._organization_id}/conversation/{conversation_id}/interaction/{interaction_id}/recommend_responses",
+        )
+        return ConversationRecommendResponsesForInteractionResponse.model_validate_json(
+            response.text
+        )
+
+    def get_interaction_insights(
+        self, conversation_id: str, interaction_id: str
+    ) -> ConversationGetInteractionInsightsResponse:
+        response = self._http.request(
+            "GET",
+            f"/v1/{self._organization_id}/conversation/{conversation_id}/interaction/{interaction_id}/insights",
+        )
+        return ConversationGetInteractionInsightsResponse.model_validate_json(
+            response.text
+        )
+
+    def get_message_source(
+        self, conversation_id: str, message_id: str
+    ) -> GetMessageSourceResponse:
+        response = self._http.request(
+            "GET",
+            f"/v1/{self._organization_id}/conversation/{conversation_id}/messages/{message_id}/source",
+        )
+        return GetMessageSourceResponse.model_validate_json(response.text)
+
+    def generate_conversation_starters(
+        self, body: ConversationGenerateConversationStarterRequest
+    ) -> ConversationGenerateConversationStarterResponse:
+        response = self._http.request(
+            "POST",
+            f"/v1/{self._organization_id}/conversation/conversation_starter",
+            json=body.model_dump(mode="json", exclude_none=True),
+        )
+        return ConversationGenerateConversationStarterResponse.model_validate_json(
+            response.text
+        )

amigo_sdk/resources/organization.py

@@ -1,13 +1,13 @@
 from amigo_sdk.generated.model import (
     OrganizationGetOrganizationResponse,
 )
-from amigo_sdk.http_client import AmigoHttpClient
+from amigo_sdk.http_client import AmigoAsyncHttpClient, AmigoHttpClient
 
 
-class OrganizationResource:
+class AsyncOrganizationResource:
     """Organization resource for Amigo API operations."""
 
-    def __init__(self, http_client: AmigoHttpClient, organization_id: str) -> None:
+    def __init__(self, http_client: AmigoAsyncHttpClient, organization_id: str) -> None:
         self._http = http_client
         self._organization_id = organization_id
 
@@ -20,3 +20,15 @@ class OrganizationResource:
         )
 
         return OrganizationGetOrganizationResponse.model_validate_json(response.text)
+
+
+class OrganizationResource:
+    def __init__(self, http_client: AmigoHttpClient, organization_id: str) -> None:
+        self._http = http_client
+        self._organization_id = organization_id
+
+    def get(self) -> OrganizationGetOrganizationResponse:
+        response = self._http.request(
+            "GET", f"/v1/{self._organization_id}/organization/"
+        )
+        return OrganizationGetOrganizationResponse.model_validate_json(response.text)

amigo_sdk/resources/service.py

@@ -4,15 +4,13 @@ from amigo_sdk.generated.model import (
     GetServicesParametersQuery,
     ServiceGetServicesResponse,
 )
-from amigo_sdk.http_client import AmigoHttpClient
+from amigo_sdk.http_client import AmigoAsyncHttpClient, AmigoHttpClient
 
 
-class ServiceResource:
+class AsyncServiceResource:
     """Service resource for Amigo API operations."""
 
-    def __init__(
-        self, http_client: AmigoHttpClient, organization_id: str
-    ) -> ServiceGetServicesResponse:
+    def __init__(self, http_client: AmigoAsyncHttpClient, organization_id: str) -> None:
         self._http = http_client
         self._organization_id = organization_id
 
@@ -28,3 +26,21 @@ class ServiceResource:
             else None,
         )
         return ServiceGetServicesResponse.model_validate_json(response.text)
+
+
+class ServiceResource:
+    def __init__(self, http_client: AmigoHttpClient, organization_id: str) -> None:
+        self._http = http_client
+        self._organization_id = organization_id
+
+    def get_services(
+        self, params: Optional[GetServicesParametersQuery] = None
+    ) -> ServiceGetServicesResponse:
+        response = self._http.request(
+            "GET",
+            f"/v1/{self._organization_id}/service/",
+            params=params.model_dump(mode="json", exclude_none=True)
+            if params
+            else None,
+        )
+        return ServiceGetServicesResponse.model_validate_json(response.text)

amigo_sdk/resources/user.py

@@ -7,13 +7,13 @@ from amigo_sdk.generated.model import (
     UserGetUsersResponse,
     UserUpdateUserInfoRequest,
 )
-from amigo_sdk.http_client import AmigoHttpClient
+from amigo_sdk.http_client import AmigoAsyncHttpClient, AmigoHttpClient
 
 
-class UserResource:
+class AsyncUserResource:
     """User resource for Amigo API operations."""
 
-    def __init__(self, http_client: AmigoHttpClient, organization_id: str) -> None:
+    def __init__(self, http_client: AmigoAsyncHttpClient, organization_id: str) -> None:
         self._http = http_client
         self._organization_id = organization_id
 
@@ -55,3 +55,43 @@ class UserResource:
             f"/v1/{self._organization_id}/user/{user_id}/user",
             json=body.model_dump(mode="json", exclude_none=True),
         )
+
+
+class UserResource:
+    """User resource (synchronous)."""
+
+    def __init__(self, http_client: AmigoHttpClient, organization_id: str) -> None:
+        self._http = http_client
+        self._organization_id = organization_id
+
+    def get_users(
+        self, params: Optional[GetUsersParametersQuery] = None
+    ) -> UserGetUsersResponse:
+        response = self._http.request(
+            "GET",
+            f"/v1/{self._organization_id}/user/",
+            params=params.model_dump(mode="json", exclude_none=True)
+            if params
+            else None,
+        )
+        return UserGetUsersResponse.model_validate_json(response.text)
+
+    def create_user(
+        self, body: UserCreateInvitedUserRequest
+    ) -> UserCreateInvitedUserResponse:
+        response = self._http.request(
+            "POST",
+            f"/v1/{self._organization_id}/user/invite",
+            json=body.model_dump(mode="json", exclude_none=True),
+        )
+        return UserCreateInvitedUserResponse.model_validate_json(response.text)
+
+    def delete_user(self, user_id: str) -> None:
+        self._http.request("DELETE", f"/v1/{self._organization_id}/user/{user_id}")
+
+    def update_user(self, user_id: str, body: UserUpdateUserInfoRequest) -> None:
+        self._http.request(
+            "POST",
+            f"/v1/{self._organization_id}/user/{user_id}/user",
+            json=body.model_dump(mode="json", exclude_none=True),
+        )

amigo_sdk/sdk_client.py

@@ -1,17 +1,21 @@
 from typing import Any, Optional
 
 from amigo_sdk.config import AmigoConfig
-from amigo_sdk.http_client import AmigoHttpClient
-from amigo_sdk.resources.conversation import ConversationResource
-from amigo_sdk.resources.organization import OrganizationResource
-from amigo_sdk.resources.service import ServiceResource
-from amigo_sdk.resources.user import UserResource
+from amigo_sdk.http_client import AmigoAsyncHttpClient, AmigoHttpClient
+from amigo_sdk.resources.conversation import (
+    AsyncConversationResource,
+    ConversationResource,
+)
+from amigo_sdk.resources.organization import (
+    AsyncOrganizationResource,
+    OrganizationResource,
+)
+from amigo_sdk.resources.service import AsyncServiceResource, ServiceResource
+from amigo_sdk.resources.user import AsyncUserResource, UserResource
 
 
-class AmigoClient:
-    """
-    Amigo API client
-    """
+class AsyncAmigoClient:
+    """Amigo API client (asynchronous)."""
 
     def __init__(
         self,
@@ -62,11 +66,15 @@ class AmigoClient:
                 ) from e
 
         # Initialize HTTP client and resources
-        self._http = AmigoHttpClient(self._cfg, **httpx_kwargs)
-        self._organization = OrganizationResource(self._http, self._cfg.organization_id)
-        self._service = ServiceResource(self._http, self._cfg.organization_id)
-        self._conversation = ConversationResource(self._http, self._cfg.organization_id)
-        self._users = UserResource(self._http, self._cfg.organization_id)
+        self._http = AmigoAsyncHttpClient(self._cfg, **httpx_kwargs)
+        self._organization = AsyncOrganizationResource(
+            self._http, self._cfg.organization_id
+        )
+        self._service = AsyncServiceResource(self._http, self._cfg.organization_id)
+        self._conversation = AsyncConversationResource(
+            self._http, self._cfg.organization_id
+        )
+        self._users = AsyncUserResource(self._http, self._cfg.organization_id)
 
     @property
     def config(self) -> AmigoConfig:
@@ -74,22 +82,22 @@ class AmigoClient:
         return self._cfg
 
     @property
-    def organization(self) -> OrganizationResource:
+    def organization(self) -> AsyncOrganizationResource:
         """Access organization resource."""
         return self._organization
 
     @property
-    def service(self) -> ServiceResource:
+    def service(self) -> AsyncServiceResource:
         """Access service resource."""
         return self._service
 
     @property
-    def conversation(self) -> ConversationResource:
+    def conversation(self) -> AsyncConversationResource:
         """Access conversation resource."""
         return self._conversation
 
     @property
-    def users(self) -> UserResource:
+    def users(self) -> AsyncUserResource:
         """Access user resource."""
         return self._users
 
@@ -103,3 +111,77 @@ class AmigoClient:
 
     async def __aexit__(self, *_):
         await self.aclose()
+
+
+class AmigoClient:
+    """Amigo API client (synchronous)."""
+
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str] = None,
+        api_key_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        organization_id: Optional[str] = None,
+        base_url: Optional[str] = None,
+        config: Optional[AmigoConfig] = None,
+        **httpx_kwargs: Any,
+    ):
+        if config:
+            self._cfg = config
+        else:
+            cfg_dict: dict[str, Any] = {
+                k: v
+                for k, v in [
+                    ("api_key", api_key),
+                    ("api_key_id", api_key_id),
+                    ("user_id", user_id),
+                    ("organization_id", organization_id),
+                    ("base_url", base_url),
+                ]
+                if v is not None
+            }
+
+            try:
+                self._cfg = AmigoConfig(**cfg_dict)
+            except Exception as e:
+                raise ValueError(
+                    "AmigoClient configuration incomplete. "
+                    "Provide api_key, api_key_id, user_id, organization_id, base_url "
+                    "either as kwargs or environment variables."
+                ) from e
+
+        self._http = AmigoHttpClient(self._cfg, **httpx_kwargs)
+        self._organization = OrganizationResource(self._http, self._cfg.organization_id)
+        self._service = ServiceResource(self._http, self._cfg.organization_id)
+        self._conversation = ConversationResource(self._http, self._cfg.organization_id)
+        self._users = UserResource(self._http, self._cfg.organization_id)
+
+    @property
+    def config(self) -> AmigoConfig:
+        return self._cfg
+
+    @property
+    def organization(self) -> OrganizationResource:
+        return self._organization
+
+    @property
+    def service(self) -> ServiceResource:
+        return self._service
+
+    @property
+    def conversation(self) -> ConversationResource:
+        return self._conversation
+
+    @property
+    def users(self) -> UserResource:
+        return self._users
+
+    def aclose(self) -> None:
+        self._http.aclose()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.aclose()

{amigo_sdk-0.8.0.dist-info → amigo_sdk-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amigo_sdk
-Version: 0.8.0
+Version: 0.9.0
 Summary: Amigo AI Python SDK
 Author: Amigo AI
 License-File: LICENSE
@@ -46,34 +46,23 @@ amigo_sdk
 
 This SDK auto-generates its types from the latest [Amigo OpenAPI schema](https://api.amigo.ai/v1/openapi.json). As a result, only the latest published SDK version is guaranteed to match the current API. If you pin to an older version, it may not include the newest endpoints or fields.
 
-## Quick Start
+## Quick Start (sync)
 
 ```python
-import asyncio
 from amigo_sdk import AmigoClient
 from amigo_sdk.generated.model import GetConversationsParametersQuery
 
-# Initialize the client
-client = AmigoClient(
+# Initialize and use the client synchronously
+with AmigoClient(
     api_key="your-api-key",
     api_key_id="your-api-key-id",
     user_id="user-id",
-    org_id="your-organization-id",
-)
-
-# List recent conversations
-async def example():
-    try:
-        async with client:
-            conversations = await client.conversation.get_conversations(
-                GetConversationsParametersQuery(limit=10, sort_by=["-created_at"])
-            )
-            print("Conversations:", conversations)
-    except Exception as error:
-        print(error)
-
-# Run the example
-asyncio.run(example())
+    organization_id="your-organization-id",
+) as client:
+    conversations = client.conversation.get_conversations(
+        GetConversationsParametersQuery(limit=10, sort_by=["-created_at"])
+    )
+    print("Conversations:", conversations)
 ```
 
 ## Examples
@@ -84,13 +73,13 @@ For more SDK usage examples see checkout the [examples/](examples/README.md) fol
 
 The SDK requires the following configuration parameters:
 
-| Parameter    | Type | Required | Description                                                    |
-| ------------ | ---- | -------- | -------------------------------------------------------------- |
-| `api_key`    | str  | ✅       | API key from Amigo dashboard                                   |
-| `api_key_id` | str  | ✅       | API key ID from Amigo dashboard                                |
-| `user_id`    | str  | ✅       | User ID on whose behalf the request is made                    |
-| `org_id`     | str  | ✅       | Your organization ID                                           |
-| `base_url`   | str  | ❌       | Base URL of the Amigo API (defaults to `https://api.amigo.ai`) |
+| Parameter         | Type | Required | Description                                                    |
+| ----------------- | ---- | -------- | -------------------------------------------------------------- |
+| `api_key`         | str  | ✅       | API key from Amigo dashboard                                   |
+| `api_key_id`      | str  | ✅       | API key ID from Amigo dashboard                                |
+| `user_id`         | str  | ✅       | User ID on whose behalf the request is made                    |
+| `organization_id` | str  | ✅       | Your organization ID                                           |
+| `base_url`        | str  | ❌       | Base URL of the Amigo API (defaults to `https://api.amigo.ai`) |
 
 ### Environment Variables
 
@@ -100,7 +89,7 @@ You can also configure the SDK using environment variables:
 export AMIGO_API_KEY="your-api-key"
 export AMIGO_API_KEY_ID="your-api-key-id"
 export AMIGO_USER_ID="user-id"
-export AMIGO_ORG_ID="your-organization-id"
+export AMIGO_ORGANIZATION_ID="your-organization-id"
 export AMIGO_BASE_URL="https://api.amigo.ai"  # optional
 ```
 
@@ -110,7 +99,8 @@ Then initialize the client without parameters:
 from amigo_sdk import AmigoClient
 
 # Automatically loads from environment variables
-client = AmigoClient()
+with AmigoClient() as client:
+    ...
 ```
 
 ### Using .env Files
@@ -153,25 +143,23 @@ from amigo_sdk.errors import (
     AuthenticationError,
     NotFoundError,
     BadRequestError,
-    ValidationError
+    ValidationError,
 )
 
-async def example_with_error_handling():
-    client = AmigoClient()
-
-    try:
-        async with client:
-            result = await client.organizations.get_organization("org-id")
-    except AuthenticationError as error:
-        print("Authentication failed:", error)
-    except NotFoundError as error:
-        print("Resource not found:", error)
-    except BadRequestError as error:
-        print("Bad request:", error)
-    except ValidationError as error:
-        print("Validation error:", error)
-    except Exception as error:
-        print("Unexpected error:", error)
+try:
+    with AmigoClient() as client:
+        org = client.organization.get()
+        print("Organization:", org)
+except AuthenticationError as error:
+    print("Authentication failed:", error)
+except NotFoundError as error:
+    print("Resource not found:", error)
+except BadRequestError as error:
+    print("Bad request:", error)
+except ValidationError as error:
+    print("Validation error:", error)
+except Exception as error:
+    print("Unexpected error:", error)
 ```
 
 ## Development

amigo_sdk-0.9.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+amigo_sdk/__init__.py,sha256=kCOODDDBTcYl4OwHYOLi80txgJizsTwkNb49c88xU0M,153
+amigo_sdk/_retry_utils.py,sha256=kFjw9Wqye6MB5-B4rjLxsbSNcfYBIztcollIoncd1hY,2142
+amigo_sdk/auth.py,sha256=WaM9PcEcnaC6CzNsgRKueHkdSAxNbRylzpR_3Q6guQ0,1765
+amigo_sdk/config.py,sha256=0eZIo-hcJ8ODftKAr-mwB-FGJxGO5PT5T4dRpyWPqAg,1491
+amigo_sdk/errors.py,sha256=RkRyF5eAASd8fIOS6YvL9rLDvLAYWqHfpHSCR7jqvl4,4840
+amigo_sdk/http_client.py,sha256=z8h8FKHRxGzULRz_C60mL5PfYSAv8e_RHUndVo0vHrM,13452
+amigo_sdk/sdk_client.py,sha256=Kr9M9o66pOLu0T2VDvqdYMmPZzgKJyTELu7BSPgGrYQ,6152
+amigo_sdk/generated/model.py,sha256=jYhncFPqXUiwOSmV6OJT82TpkmjG5LZH_gFRFr7mTEs,427161
+amigo_sdk/resources/conversation.py,sha256=pGM2vtUsem8ClVfzZne1qqKZdM4o7aWaRdAYXXKEMFw,14784
+amigo_sdk/resources/organization.py,sha256=yX4UlOHNegRzFW4gCJrCxjiLCAGnGegasjviR1yad_Q,1211
+amigo_sdk/resources/service.py,sha256=SiwEHXCQk4r1b_tGv47M08VuB7RALDHJQzWlpuD937g,1571
+amigo_sdk/resources/user.py,sha256=i4t5aVzBI37KwAtLKSDWTMwf4D4KQdSDoUiblFe1u7o,3529
+amigo_sdk-0.9.0.dist-info/METADATA,sha256=KOQJZyfLcA-ZbG8w22B24yP4XUvUDiUbeUct_4gWMyE,5982
+amigo_sdk-0.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+amigo_sdk-0.9.0.dist-info/entry_points.txt,sha256=ivKZ8S9W6SH796zUDHeM-qHodrwmkmUItophi-jJWK0,82
+amigo_sdk-0.9.0.dist-info/licenses/LICENSE,sha256=tx3FiTVbGxwBUOxQbNh05AAQlC2jd5hGvNpIkSfVbCo,1062
+amigo_sdk-0.9.0.dist-info/RECORD,,

amigo_sdk-0.8.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-amigo_sdk/__init__.py,sha256=iPlYCcIzuzW7T2HKDkmYlMkRI51dBLfNRxPPiWrfw9U,22
-amigo_sdk/auth.py,sha256=Kvwk4P2HJaVUIn2Lwj7l6_xTm0IOVxMlthiXthm-V2Y,1029
-amigo_sdk/config.py,sha256=0eZIo-hcJ8ODftKAr-mwB-FGJxGO5PT5T4dRpyWPqAg,1491
-amigo_sdk/errors.py,sha256=RkRyF5eAASd8fIOS6YvL9rLDvLAYWqHfpHSCR7jqvl4,4840
-amigo_sdk/http_client.py,sha256=XDtcQnAXf4E46Kjl6tKVVFgrMgozjCbOcDf21aK_c4s,8843
-amigo_sdk/sdk_client.py,sha256=yLK8f0ARxLOlJX_cM-Y1GW-zCgJWsL2LIrWMxQGaMhY,3685
-amigo_sdk/generated/model.py,sha256=JSpAiUZ_1vrAp7pG3EcOdlXpFAG8w0hd0qKDo_orw9E,427393
-amigo_sdk/resources/conversation.py,sha256=gRkZwqLGOscqoCFcagwU-NfTeMuvLsuEqN_uLyNu1NI,8514
-amigo_sdk/resources/organization.py,sha256=HNwUgeggeEklvcwFS7Of6nGDawN-_Uvd9NsXtcYg65o,726
-amigo_sdk/resources/service.py,sha256=DrKaLnKAglcCeZJQEw50hAOLWtW_InnOu551TxgwF60,947
-amigo_sdk/resources/user.py,sha256=Y66Eb5kH3sYWpdx1E9PP8slban8jpUHmig3YEXHaD_Y,2066
-amigo_sdk-0.8.0.dist-info/METADATA,sha256=UIgZqBJj4VYy8lbcqRIg_CtEaGCzafi0s2KlAXGHz88,6215
-amigo_sdk-0.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-amigo_sdk-0.8.0.dist-info/entry_points.txt,sha256=ivKZ8S9W6SH796zUDHeM-qHodrwmkmUItophi-jJWK0,82
-amigo_sdk-0.8.0.dist-info/licenses/LICENSE,sha256=tx3FiTVbGxwBUOxQbNh05AAQlC2jd5hGvNpIkSfVbCo,1062
-amigo_sdk-0.8.0.dist-info/RECORD,,