meshapi 0.1.0__tar.gz → 0.1.2__tar.gz

{meshapi-0.1.0 → meshapi-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshapi
-Version: 0.1.0
+Version: 0.1.2
 Summary: Official Python SDK for the MeshAPI AI model gateway
 Project-URL: Homepage, https://meshapi.ai
 Project-URL: Documentation, https://developers.meshapi.ai

{meshapi-0.1.0 → meshapi-0.1.2}/meshapi/_http.py

@@ -8,7 +8,17 @@ import math
 import random
 import time
 from dataclasses import dataclass, field
-from typing import Any, AsyncIterator, Dict, Iterator, Optional, Set, Type, TypeVar, Union
+from typing import (
+    Any,
+    AsyncIterator,
+    Dict,
+    Iterator,
+    Optional,
+    Set,
+    Type,
+    TypeVar,
+    Union,
+)
 
 import httpx
 
@@ -52,12 +62,19 @@ def _extract_sse_data(frame: str) -> Optional[str]:
     data_lines = []
     for line in frame.splitlines():
         if line.startswith("data: "):
-            data_lines.append(line[len("data: "):])
+            data_lines.append(line[len("data: ") :])
     if not data_lines:
         return None
     return "\n".join(data_lines)
 
 
+def _extract_sse_event(frame: str) -> Optional[str]:
+    for line in frame.splitlines():
+        if line.startswith("event: "):
+            return line[len("event: ") :]
+    return None
+
+
 def _try_parse_sse_frame(frame: str) -> "Optional[Union[ChatCompletionChunk, object]]":
     """Parse one SSE frame string.
 
@@ -78,19 +95,33 @@ def _try_parse_sse_frame(frame: str) -> "Optional[Union[ChatCompletionChunk, obj
     except json.JSONDecodeError:
         return None
 
-    if isinstance(parsed, dict) and "error" in parsed:
+    if isinstance(parsed, dict) and parsed.get("error") is not None:
         err = parsed["error"]
-        raise MeshAPIError(
-            err.get("message", "upstream error"),
-            status=0,
-            error_code=err.get("code", "upstream_error"),
-            request_id="",
-        )
+        if isinstance(err, dict):
+            raise MeshAPIError(
+                err.get("message", "upstream error"),
+                status=0,
+                error_code=err.get("code", "upstream_error"),
+                request_id="",
+            )
+        else:
+            raise MeshAPIError(
+                str(err),
+                status=0,
+                error_code="upstream_error",
+                request_id="",
+            )
+
+    sse_event = _extract_sse_event(frame)
+    if isinstance(parsed, dict) and sse_event is not None:
+        parsed["event"] = sse_event
 
     return ChatCompletionChunk.model_validate(parsed)
 
 
-def _try_parse_json_sse_frame(frame: str, model_cls: Type[T]) -> Optional[Union[T, object]]:
+def _try_parse_json_sse_frame(
+    frame: str, model_cls: Type[T]
+) -> Optional[Union[T, object]]:
     data_line = _extract_sse_data(frame)
     if data_line is None or data_line.strip() == "":
         return None
@@ -100,14 +131,27 @@ def _try_parse_json_sse_frame(frame: str, model_cls: Type[T]) -> Optional[Union[
         parsed = json.loads(data_line)
     except json.JSONDecodeError:
         return None
-    if isinstance(parsed, dict) and "error" in parsed:
+    if isinstance(parsed, dict) and parsed.get("error") is not None:
         err = parsed["error"]
-        raise MeshAPIError(
-            err.get("message", "upstream error"),
-            status=0,
-            error_code=err.get("code", "upstream_error"),
-            request_id="",
-        )
+        if isinstance(err, dict):
+            raise MeshAPIError(
+                err.get("message", "upstream error"),
+                status=0,
+                error_code=err.get("code", "upstream_error"),
+                request_id="",
+            )
+        else:
+            raise MeshAPIError(
+                str(err),
+                status=0,
+                error_code="upstream_error",
+                request_id="",
+            )
+
+    sse_event = _extract_sse_event(frame)
+    if isinstance(parsed, dict) and sse_event is not None:
+        parsed["event"] = sse_event
+
     return model_cls.model_validate(parsed)
 
 
@@ -185,7 +229,9 @@ async def _aiter_sse(response: httpx.Response) -> AsyncIterator[ChatCompletionCh
         raise MeshAPIError.stream_interrupted(str(exc)) from exc
 
 
-async def _aiter_json_sse(response: httpx.Response, model_cls: Type[T]) -> AsyncIterator[T]:
+async def _aiter_json_sse(
+    response: httpx.Response, model_cls: Type[T]
+) -> AsyncIterator[T]:
     remainder = ""
     try:
         async for raw_bytes in response.aiter_bytes():
@@ -219,7 +265,7 @@ def _compute_delay_s(attempt: int, retry_after: Optional[int]) -> float:
     if retry_after is not None:
         base = retry_after * 1000
     else:
-        base = _BACKOFF_BASE_MS * (2 ** attempt)
+        base = _BACKOFF_BASE_MS * (2**attempt)
     capped = min(base, _BACKOFF_MAX_MS)
     jittered = capped * (0.8 + random.random() * 0.4)  # ±20%
     return jittered / 1000.0
@@ -286,7 +332,10 @@ class SyncHttpClient:
                 return req
 
             response = self._client.request(method, path, **kwargs)
-            if response.status_code in _RETRY_STATUS_CODES and attempt < self._config.max_retries:
+            if (
+                response.status_code in _RETRY_STATUS_CODES
+                and attempt < self._config.max_retries
+            ):
                 delay = _compute_delay_s(attempt, _retry_after_from_response(response))
                 time.sleep(delay)
                 continue
@@ -325,12 +374,16 @@ class SyncHttpClient:
         return response.content
 
     def stream(self, path: str, body: Any) -> Iterator[ChatCompletionChunk]:
-        with self._client.stream("POST", path, json=body, headers=self._headers()) as response:
+        with self._client.stream(
+            "POST", path, json=body, headers=self._headers()
+        ) as response:
             _raise_for_status(response)
             yield from _iter_sse(response)
 
     def stream_json(self, path: str, body: Any, model_cls: Type[T]) -> Iterator[T]:
-        with self._client.stream("POST", path, json=body, headers=self._headers()) as response:
+        with self._client.stream(
+            "POST", path, json=body, headers=self._headers()
+        ) as response:
             _raise_for_status(response)
             yield from _iter_json_sse(response, model_cls)
 
@@ -382,7 +435,10 @@ class AsyncHttpClient:
 
         for attempt in range(self._config.max_retries + 1):
             response = await self._client.request(method, path, **kwargs)
-            if response.status_code in _RETRY_STATUS_CODES and attempt < self._config.max_retries:
+            if (
+                response.status_code in _RETRY_STATUS_CODES
+                and attempt < self._config.max_retries
+            ):
                 delay = _compute_delay_s(attempt, _retry_after_from_response(response))
                 await asyncio.sleep(delay)
                 continue
@@ -414,7 +470,9 @@ class AsyncHttpClient:
         if response.status_code == 204:
             return
 
-    async def get_bytes(self, path: str, *, params: Optional[Dict[str, Any]] = None) -> bytes:
+    async def get_bytes(
+        self, path: str, *, params: Optional[Dict[str, Any]] = None
+    ) -> bytes:
         response = await self._request("GET", path, params=params)
         return response.content
 
@@ -426,7 +484,9 @@ class AsyncHttpClient:
             async for chunk in _aiter_sse(response):
                 yield chunk
 
-    async def stream_json(self, path: str, body: Any, model_cls: Type[T]) -> AsyncIterator[T]:
+    async def stream_json(
+        self, path: str, body: Any, model_cls: Type[T]
+    ) -> AsyncIterator[T]:
         async with self._client.stream(
             "POST", path, json=body, headers=self._headers()
         ) as response:

{meshapi-0.1.0 → meshapi-0.1.2}/meshapi/_types.py

@@ -59,6 +59,20 @@ class ToolCall(BaseModel):
     function: ToolCallFunction
 
 
+class ToolCallFunctionChunk(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    name: Optional[str] = None
+    arguments: Optional[str] = None
+
+
+class ToolCallChunk(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    index: int
+    id: Optional[str] = None
+    type: Optional[Literal["function"]] = None
+    function: Optional[ToolCallFunctionChunk] = None
+
+
 class ChatMessage(BaseModel):
     model_config = ConfigDict(extra="ignore")
     role: ChatRole
@@ -194,7 +208,7 @@ class ChatCompletionChunkDelta(BaseModel):
     model_config = ConfigDict(extra="ignore")
     role: Optional[str] = None
     content: Optional[str] = None
-    tool_calls: Optional[List[ToolCall]] = None
+    tool_calls: Optional[List[ToolCallChunk]] = None
     audio: Optional[Dict[str, Any]] = None
 
 
@@ -489,6 +503,22 @@ class CompareStreamEvent(BaseModel):
     event: Optional[str] = None
     data: Optional[Dict[str, Any]] = None
 
+    # Common fields flattened from various compare event types
+    delta: Optional[str] = None
+    model: Optional[str] = None
+    comparison_id: Optional[str] = None
+    comparison_model: Optional[str] = None
+    models: Optional[List[str]] = None
+    latency_ms: Optional[int] = None
+    total_latency_ms: Optional[int] = None
+    finish_reason: Optional[str] = None
+    error: Optional[Any] = None
+    error_code: Optional[str] = None
+    usage: Optional[Dict[str, Any]] = None
+    skip_comparison: Optional[bool] = None
+    partial: Optional[bool] = None
+    comparison_fallback_used: Optional[bool] = None
+
 
 # ---------------------------------------------------------------------------
 # Files / Batches

{meshapi-0.1.0 → meshapi-0.1.2}/pyproject.toml

@@ -4,14 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meshapi"
-version = "0.1.0"
+version = "0.1.2"
 description = "Official Python SDK for the MeshAPI AI model gateway"
 readme = "README.md"
 requires-python = ">=3.9"
 license = { text = "MIT" }
-authors = [
-    { name = "MeshAPI", email = "contact@meshapi.ai" },
-]
+authors = [{ name = "MeshAPI", email = "contact@meshapi.ai" }]
 keywords = [
     "meshapi",
     "llm",
@@ -39,17 +37,10 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Typing :: Typed",
 ]
-dependencies = [
-    "httpx>=0.27.0",
-    "pydantic>=2.0.0",
-]
+dependencies = ["httpx>=0.27.0", "pydantic>=2.0.0"]
 
 [project.optional-dependencies]
-dev = [
-    "pytest>=8.0.0",
-    "pytest-asyncio>=0.23.0",
-    "respx>=0.21.0",
-]
+dev = ["pytest>=8.0.0", "pytest-asyncio>=0.23.0", "respx>=0.21.0"]
 
 [project.urls]
 Homepage = "https://meshapi.ai"
@@ -62,11 +53,7 @@ Changelog = "https://github.com/aifiesta/meshapi-python-sdk/blob/main/CHANGELOG.
 packages = ["meshapi"]
 
 [tool.hatch.build.targets.sdist]
-exclude = [
-    "tests/",
-    ".github/",
-    "*.egg-info",
-]
+exclude = ["tests/", ".github/", "*.egg-info"]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"