meshapi 0.1.4__tar.gz → 0.1.6__tar.gz

{meshapi-0.1.4 → meshapi-0.1.6}/CLAUDE.md

@@ -147,6 +147,70 @@ pytest test_rag.py::test_rag_upload_embed_search -v
 | `test_rag.py` | RAG upload → embed → list → search |
 | `test_realtime.py` | WebSocket connect/close, session.created, session.update, error envelopes, iterator API, async variants |
 
+### Available live test files (updated)
+
+| File | What it tests |
+|------|---------------|
+| `test_chat.py` | Chat completions (basic, tools, multi-turn) |
+| `test_stream.py` | Streaming chat and responses |
+| `test_models.py` | Model listing |
+| `test_templates.py` | Template CRUD lifecycle |
+| `test_inference_resources.py` | Embeddings, responses |
+| `test_errors.py` | 401/404 error handling |
+| `test_feature_matrix.py` | Cross-model feature matrix |
+| `test_rag.py` | RAG upload → embed → list → search |
+| `test_realtime.py` | WebSocket connect/close, session lifecycle |
+| `test_audio.py` | TTS synthesize, voice listing |
+| `test_video.py` | Video list, generate → retrieve |
+| `test_compare.py` | Non-streaming compare, streaming compare |
+
+---
+
+## Contribution checklist
+
+Every SDK change — however small — must include all of the following before merging:
+
+1. **Live tests** — add or update `livetests/test_<resource>.py` to cover the new/changed behaviour.
+2. **Unit / contract tests** — if the change affects request/response serialisation or error handling, add a test in `tests/unit/` or `tests/contract/`.
+3. **README** — update `README.md` with a usage example for any new or changed public surface.
+4. **meshapi-docs** — open a follow-up PR (or note in the PR description) to update the [meshapi-docs](https://github.com/aifiesta/meshapi-docs) repository so the developer documentation stays in sync.
+
+---
+
+---
+
+## Release
+
+Releases are triggered by pushing a `v*` git tag. The `publish.yml` workflow builds the package with hatch and publishes to PyPI via OIDC (no API token needed).
+
+### Release checklist
+
+1. **Bump the version** in `pyproject.toml`:
+   ```toml
+   version = "0.1.6"
+   ```
+
+2. **Commit the version bump**:
+   ```bash
+   git add pyproject.toml
+   git commit -m "chore: bump version to 0.1.6"
+   ```
+
+3. **Tag and push**:
+   ```bash
+   git tag v0.1.6
+   git push origin main
+   git push origin v0.1.6
+   ```
+
+4. **Monitor the workflow** at `Actions → Publish to PyPI`.
+
+5. **Verify** the new version is live:
+   ```bash
+   pip install meshapi==0.1.6
+   python -c "import meshapi; print(meshapi.__version__)"
+   ```
+
 ### RAG live test notes
 
 `test_rag_upload_embed_search` does the following:

{meshapi-0.1.4 → meshapi-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshapi
-Version: 0.1.4
+Version: 0.1.6
 Summary: Official Python SDK for the MeshAPI AI model gateway
 Project-URL: Homepage, https://meshapi.ai
 Project-URL: Documentation, https://developers.meshapi.ai
@@ -80,6 +80,8 @@ Get a key at [meshapi.ai](https://meshapi.ai). Data-plane keys are prefixed `rsk
 | **Reasoning models** | First-class `responses` API with `reasoning.effort` and `max_output_tokens`. |
 | **Embeddings** | Drop-in OpenAI-compatible embeddings endpoint. |
 | **Multi-model compare** | Fire one prompt at N models in parallel and stream their replies side by side. |
+| **Audio** | Text-to-speech, speech-to-text, transcription translation, and voice listing. |
+| **Video** | Submit and poll async video generation tasks. |
 | **RAG** | Upload files, embed them, and run vector search — all through the same client. |
 | **Batches** | Async bulk inference jobs at discounted rates with inline request submission. |
 | **Prompt templates** | Server-stored prompts with `{{variable}}` slots. Update prompts without redeploying. |
@@ -199,6 +201,91 @@ result = client.embeddings.create(
 print(len(result.data[0].embedding))
 ```
 
+## Audio (TTS, STT, voices)
+
+```python
+from meshapi import SpeechParams, TranscriptionParams, ListVoicesParams
+
+# Text-to-speech — returns raw audio bytes
+audio_bytes = client.audio.synthesize(
+    SpeechParams(
+        input="Hello from MeshAPI.",
+        model="sarvam/bulbul:v2",
+        voice="meera",
+    )
+)
+with open("output.wav", "wb") as f:
+    f.write(audio_bytes)
+
+# Speech-to-text — submit transcription job
+result = client.audio.transcribe(
+    TranscriptionParams(
+        model="sarvam/saaras:v3",
+        file=open("audio.wav", "rb").read(),
+        file_name="audio.wav",
+        language="en",
+    )
+)
+print(result.text)
+
+# Translate audio to English
+translated = client.audio.translate(
+    TranscriptionParams(
+        model="sarvam/saaras:v3",
+        file=open("audio.wav", "rb").read(),
+        file_name="audio.wav",
+    )
+)
+print(translated.text)
+
+# List available voices
+voices = client.audio.list_voices(ListVoicesParams(page_size=10))
+
+# Get a specific voice
+voice = client.audio.get_voice("voice-id")
+```
+
+### Async audio
+
+```python
+audio_bytes = await client.audio.synthesize(SpeechParams(input="Hello!", model="sarvam/bulbul:v2"))
+voices = await client.audio.list_voices(ListVoicesParams())
+```
+
+## Video generation
+
+```python
+from meshapi import VideoGenerationParams, VideoContentItem, ListVideoGenerationsParams
+import time
+
+# Submit a video generation task
+task = client.videos.generate(
+    VideoGenerationParams(
+        model="byteplus/dreamina-seedance-2-0",
+        content=[VideoContentItem(type="text", text="A serene mountain lake at sunrise")],
+    )
+)
+print(f"Task ID: {task.id}")
+
+# Poll until complete
+while True:
+    status = client.videos.retrieve(task.id)
+    if status.status in ("succeeded", "failed"):
+        break
+    time.sleep(5)
+
+# List past generation tasks
+listing = client.videos.list(ListVideoGenerationsParams(limit=20))
+print(f"{listing.total} total tasks")
+```
+
+### Async video
+
+```python
+task = await client.videos.generate(VideoGenerationParams(...))
+status = await client.videos.retrieve(task.id)
+```
+
 ## Image generation
 
 ```python
@@ -433,6 +520,13 @@ from meshapi import (
     RagFileStatus, RagFileListResponse,
     BulkEmbedRequest, BulkEmbedResponse,
     SearchRequest, SearchResponse, SearchResult,
+    # audio
+    SpeechParams, TranscriptionParams, TranscriptionTranslateParams,
+    TranscriptionResponse, ListVoicesParams,
+    # video
+    VideoGenerationParams, VideoContentItem,
+    CreateVideoGenerationResponse, VideoTaskResponse, VideoTaskListResponse,
+    ListVideoGenerationsParams,
     # models
     ModelInfo, ModelPricing,
     # templates

{meshapi-0.1.4 → meshapi-0.1.6}/README.md

@@ -43,6 +43,8 @@ Get a key at [meshapi.ai](https://meshapi.ai). Data-plane keys are prefixed `rsk
 | **Reasoning models** | First-class `responses` API with `reasoning.effort` and `max_output_tokens`. |
 | **Embeddings** | Drop-in OpenAI-compatible embeddings endpoint. |
 | **Multi-model compare** | Fire one prompt at N models in parallel and stream their replies side by side. |
+| **Audio** | Text-to-speech, speech-to-text, transcription translation, and voice listing. |
+| **Video** | Submit and poll async video generation tasks. |
 | **RAG** | Upload files, embed them, and run vector search — all through the same client. |
 | **Batches** | Async bulk inference jobs at discounted rates with inline request submission. |
 | **Prompt templates** | Server-stored prompts with `{{variable}}` slots. Update prompts without redeploying. |
@@ -162,6 +164,91 @@ result = client.embeddings.create(
 print(len(result.data[0].embedding))
 ```
 
+## Audio (TTS, STT, voices)
+
+```python
+from meshapi import SpeechParams, TranscriptionParams, ListVoicesParams
+
+# Text-to-speech — returns raw audio bytes
+audio_bytes = client.audio.synthesize(
+    SpeechParams(
+        input="Hello from MeshAPI.",
+        model="sarvam/bulbul:v2",
+        voice="meera",
+    )
+)
+with open("output.wav", "wb") as f:
+    f.write(audio_bytes)
+
+# Speech-to-text — submit transcription job
+result = client.audio.transcribe(
+    TranscriptionParams(
+        model="sarvam/saaras:v3",
+        file=open("audio.wav", "rb").read(),
+        file_name="audio.wav",
+        language="en",
+    )
+)
+print(result.text)
+
+# Translate audio to English
+translated = client.audio.translate(
+    TranscriptionParams(
+        model="sarvam/saaras:v3",
+        file=open("audio.wav", "rb").read(),
+        file_name="audio.wav",
+    )
+)
+print(translated.text)
+
+# List available voices
+voices = client.audio.list_voices(ListVoicesParams(page_size=10))
+
+# Get a specific voice
+voice = client.audio.get_voice("voice-id")
+```
+
+### Async audio
+
+```python
+audio_bytes = await client.audio.synthesize(SpeechParams(input="Hello!", model="sarvam/bulbul:v2"))
+voices = await client.audio.list_voices(ListVoicesParams())
+```
+
+## Video generation
+
+```python
+from meshapi import VideoGenerationParams, VideoContentItem, ListVideoGenerationsParams
+import time
+
+# Submit a video generation task
+task = client.videos.generate(
+    VideoGenerationParams(
+        model="byteplus/dreamina-seedance-2-0",
+        content=[VideoContentItem(type="text", text="A serene mountain lake at sunrise")],
+    )
+)
+print(f"Task ID: {task.id}")
+
+# Poll until complete
+while True:
+    status = client.videos.retrieve(task.id)
+    if status.status in ("succeeded", "failed"):
+        break
+    time.sleep(5)
+
+# List past generation tasks
+listing = client.videos.list(ListVideoGenerationsParams(limit=20))
+print(f"{listing.total} total tasks")
+```
+
+### Async video
+
+```python
+task = await client.videos.generate(VideoGenerationParams(...))
+status = await client.videos.retrieve(task.id)
+```
+
 ## Image generation
 
 ```python
@@ -396,6 +483,13 @@ from meshapi import (
     RagFileStatus, RagFileListResponse,
     BulkEmbedRequest, BulkEmbedResponse,
     SearchRequest, SearchResponse, SearchResult,
+    # audio
+    SpeechParams, TranscriptionParams, TranscriptionTranslateParams,
+    TranscriptionResponse, ListVoicesParams,
+    # video
+    VideoGenerationParams, VideoContentItem,
+    CreateVideoGenerationResponse, VideoTaskResponse, VideoTaskListResponse,
+    ListVideoGenerationsParams,
     # models
     ModelInfo, ModelPricing,
     # templates

meshapi-0.1.6/livetests/test_audio.py

@@ -0,0 +1,40 @@
+"""Live tests for /v1/audio/* endpoints."""
+
+from __future__ import annotations
+
+import os
+
+from meshapi import MeshAPI, SpeechParams, ListVoicesParams, TranscriptionParams
+
+TTS_MODEL = os.environ.get("MESHAPI_TTS_MODEL", "sarvam/bulbul:v2")
+STT_MODEL = os.environ.get("MESHAPI_STT_MODEL", "sarvam/saaras:v3")
+
+
+def test_audio_synthesize(client: MeshAPI) -> None:
+    params = SpeechParams(input="Hello from MeshAPI audio test.", model=TTS_MODEL)
+    audio_bytes = client.audio.synthesize(params)
+    assert isinstance(audio_bytes, bytes)
+    assert len(audio_bytes) > 0
+    print(f"[PASS] audio.synthesize -> {len(audio_bytes)} bytes")
+
+
+def test_audio_stt_from_tts(client: MeshAPI) -> None:
+    audio_bytes = client.audio.synthesize(
+        SpeechParams(input="Hello from MeshAPI audio test.", model=TTS_MODEL)
+    )
+    assert isinstance(audio_bytes, bytes) and len(audio_bytes) > 0, "TTS step failed"
+
+    result = client.audio.transcribe(
+        audio_bytes,
+        TranscriptionParams(model=STT_MODEL),
+        filename="tts_output.wav",
+    )
+    assert result is not None
+    assert isinstance(result.text, str) and len(result.text) > 0
+    print(f"[PASS] audio.transcribe (via TTS audio) -> {result.text!r}")
+
+
+def test_audio_list_voices(client: MeshAPI) -> None:
+    voices = client.audio.list_voices(ListVoicesParams(page_size=5))
+    assert voices is not None
+    print(f"[PASS] audio.list_voices -> {type(voices)}")

meshapi-0.1.6/livetests/test_compare.py

@@ -0,0 +1,38 @@
+"""Live tests: Model Compare API."""
+
+from __future__ import annotations
+
+import pytest
+from meshapi import MeshAPI, CompareParams, ChatMessage
+
+
+def test_compare_nonstreaming(client: MeshAPI, model: str, second_model: str) -> None:
+    result = client.compare.create(
+        CompareParams(
+            models=[model, second_model],
+            messages=[ChatMessage(role="user", content="What is 2+2? Reply in one word.")],
+            skip_comparison=True,
+            max_tokens=20,
+        )
+    )
+    assert result.comparison_id, "expected comparison_id"
+    assert len(result.results) == 2, f"expected 2 results, got {len(result.results)}"
+    found_models = {r.model for r in result.results}
+    assert model in found_models, f"expected {model} in results"
+    assert second_model in found_models, f"expected {second_model} in results"
+    for r in result.results:
+        assert r.content or r.error, f"result for {r.model} has neither content nor error"
+
+
+def test_compare_streaming(client: MeshAPI, model: str, second_model: str) -> None:
+    events = list(
+        client.compare.stream(
+            CompareParams(
+                models=[model, second_model],
+                messages=[ChatMessage(role="user", content="Tell me a joke.")],
+                skip_comparison=True,
+                max_tokens=50,
+            )
+        )
+    )
+    assert len(events) > 0, "expected at least one streaming event"

{meshapi-0.1.4 → meshapi-0.1.6}/livetests/test_inference_resources.py

@@ -98,7 +98,6 @@ def test_compare_create(client: MeshAPI, model: str, second_model: str) -> None:
     assert len(result.results) == 2, f"expected 2 results, got {len(result.results)}"
 
 
-@pytest.mark.xfail(reason="server-side SQLAlchemy session concurrency issue when compare tests run back-to-back")
 def test_compare_stream(client: MeshAPI, model: str, second_model: str) -> None:
     events = list(
         client.compare.stream(

{meshapi-0.1.4 → meshapi-0.1.6}/livetests/test_rag.py

@@ -102,7 +102,7 @@ def test_rag_upload_embed_search(client: MeshAPI) -> None:
     # ── Step 7: Search ──
     search_resp = client.rag.search(
         SearchRequest(
-            query="meshapi rag livetest py",
+            query="summary",
             top_k=5,
             file_ids=[upload.file_id],
         )

meshapi-0.1.6/livetests/test_structured_output.py

@@ -0,0 +1,86 @@
+"""Live tests: Structured output (response_format with JSON schema)."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+from meshapi import MeshAPI, ChatCompletionParams, ChatMessage
+
+MODELS = [
+    "openai/gpt-4o-mini",
+    "google/gemini-3-flash-preview",
+]
+
+_SCHEMA = {
+    "type": "json_schema",
+    "json_schema": {
+        "name": "country_info",
+        "schema": {
+            "type": "object",
+            "properties": {
+                "capital": {"type": "string"},
+                "country": {"type": "string"},
+            },
+            "required": ["capital", "country"],
+            "additionalProperties": False,
+        },
+    },
+}
+
+
+@pytest.mark.parametrize("so_model", MODELS)
+def test_structured_output_fields(client: MeshAPI, so_model: str) -> None:
+    resp = client.chat.completions.create(
+        ChatCompletionParams(
+            model=so_model,
+            messages=[ChatMessage(role="user", content="What is the capital of France? Use the provided schema.")],
+            response_format=_SCHEMA,
+            max_tokens=1000,
+            temperature=0,
+        )
+    )
+    assert resp.choices, "expected choices"
+    content = resp.choices[0].message.content
+    assert content, "expected non-empty content"
+
+    data = json.loads(content)
+    assert "capital" in data, f"missing 'capital' field: {data}"
+    assert "country" in data, f"missing 'country' field: {data}"
+    assert isinstance(data["capital"], str), f"'capital' must be a string: {data}"
+    assert isinstance(data["country"], str), f"'country' must be a string: {data}"
+    assert "paris" in data["capital"].lower(), f"expected Paris as capital, got: {data}"
+
+
+@pytest.mark.parametrize("so_model", MODELS)
+def test_structured_output_finish_reason(client: MeshAPI, so_model: str) -> None:
+    resp = client.chat.completions.create(
+        ChatCompletionParams(
+            model=so_model,
+            messages=[ChatMessage(role="user", content="Name any planet in our solar system. Use the provided schema.")],
+            response_format={
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "planet_info",
+                    "schema": {
+                        "type": "object",
+                        "properties": {
+                            "name": {"type": "string"},
+                            "position_from_sun": {"type": "integer"},
+                        },
+                        "required": ["name", "position_from_sun"],
+                        "additionalProperties": False,
+                    },
+                },
+            },
+            max_tokens=1000,
+            temperature=0,
+        )
+    )
+    assert resp.choices[0].finish_reason == "stop", (
+        f"expected finish_reason 'stop', got {resp.choices[0].finish_reason!r}"
+    )
+    data = json.loads(resp.choices[0].message.content)
+    assert "name" in data
+    assert "position_from_sun" in data
+    assert isinstance(data["position_from_sun"], int), f"expected integer position: {data}"

meshapi-0.1.6/livetests/test_video.py

@@ -0,0 +1,30 @@
+"""Live tests for /v1/video/generations endpoints."""
+
+from __future__ import annotations
+
+import os
+
+from meshapi import MeshAPI, VideoGenerationParams, VideoContentItem, ListVideoGenerationsParams
+
+VIDEO_MODEL = os.environ.get("MESHAPI_VIDEO_GEN_MODEL", "byteplus/dreamina-seedance-2-0")
+
+
+def test_video_list(client: MeshAPI) -> None:
+    listing = client.videos.list(ListVideoGenerationsParams(limit=5))
+    assert listing.data is not None
+    print(f"[PASS] videos.list -> total={listing.total}, items={len(listing.data)}")
+
+
+def test_video_generate_and_retrieve(client: MeshAPI) -> None:
+    params = VideoGenerationParams(
+        model=VIDEO_MODEL,
+        content=[VideoContentItem(type="text", text="A serene mountain lake at sunrise")],
+    )
+    resp = client.videos.generate(params)
+    assert resp.id
+    print(f"[PASS] videos.generate -> task_id={resp.id}")
+
+    task = client.videos.retrieve(resp.id)
+    assert task.id == resp.id
+    assert task.status
+    print(f"[PASS] videos.retrieve -> status={task.status}")

{meshapi-0.1.4 → meshapi-0.1.6}/meshapi/__init__.py

@@ -10,6 +10,15 @@ from ._types import (
     ApiErrorBody,
     ApiErrorEnvelope,
     BulkEmbedRequest,
+    ListVoicesParams,
+    PronunciationDictionaryLocator,
+    SpeechParams,
+    TranscriptionParams,
+    TranscriptionResponse,
+    TranscriptionTranslateParams,
+    Voice,
+    VoicesResponse,
+    VoiceSettings,
     BulkEmbedResponse,
     BulkEmbedResult,
     ChatCompletionChunk,
@@ -42,6 +51,15 @@ from ._types import (
     ImageItem,
     ImageOptions,
     ImageUsage,
+    CreateVideoGenerationResponse,
+    ListVideoGenerationsParams,
+    VideoContentItem,
+    VideoGenerationParams,
+    VideoTaskContent,
+    VideoTaskError,
+    VideoTaskListResponse,
+    VideoTaskResponse,
+    VideoTaskUsage,
     InputAudio,
     ListModelsParams,
     ModelOverride,
@@ -75,6 +93,8 @@ from ._types import (
     UpdateTemplateParams,
     UsageInfo,
 )
+from .resources.audio import AsyncAudioResource, AudioResource
+from .resources.videos import AsyncVideosResource, VideosResource
 from .resources.batches import AsyncBatchesResource, BatchesResource
 from .resources.chat import AsyncChatResource, ChatResource
 from .resources.compare import AsyncCompareResource, CompareResource
@@ -178,6 +198,30 @@ __all__ = [
     "SearchRequest",
     "SearchResult",
     "SearchResponse",
+    # Video
+    "VideosResource",
+    "AsyncVideosResource",
+    "CreateVideoGenerationResponse",
+    "ListVideoGenerationsParams",
+    "VideoContentItem",
+    "VideoGenerationParams",
+    "VideoTaskContent",
+    "VideoTaskError",
+    "VideoTaskListResponse",
+    "VideoTaskResponse",
+    "VideoTaskUsage",
+    # Audio
+    "AudioResource",
+    "AsyncAudioResource",
+    "SpeechParams",
+    "VoiceSettings",
+    "PronunciationDictionaryLocator",
+    "TranscriptionParams",
+    "TranscriptionTranslateParams",
+    "TranscriptionResponse",
+    "ListVoicesParams",
+    "Voice",
+    "VoicesResponse",
 ]
 
 
@@ -226,6 +270,8 @@ class MeshAPI:
         self.models = ModelsResource(http)
         self.templates = TemplatesResource(http)
         self.images = ImagesResource(http)
+        self.videos = VideosResource(http)
+        self.audio = AudioResource(http)
         self.rag = RagResource(http)
         self.realtime = RealtimeResource(config)
         self._http = http
@@ -284,6 +330,8 @@ class AsyncMeshAPI:
         self.models = AsyncModelsResource(http)
         self.templates = AsyncTemplatesResource(http)
         self.images = AsyncImagesResource(http)
+        self.videos = AsyncVideosResource(http)
+        self.audio = AsyncAudioResource(http)
         self.rag = AsyncRagResource(http)
         self.realtime = AsyncRealtimeResource(config)
         self._http = http

{meshapi-0.1.4 → meshapi-0.1.6}/meshapi/_http.py

@@ -373,6 +373,23 @@ class SyncHttpClient:
         response = self._request("GET", path, params=params)
         return response.content
 
+    def post_bytes(self, path: str, body: Any) -> bytes:
+        response = self._request("POST", path, json_body=body)
+        return response.content
+
+    def post_multipart(self, path: str, fields: Dict[str, Any], file_data: Optional[tuple] = None, file_field: str = "file") -> Any:
+        headers = {k: v for k, v in self._headers().items() if k != "Content-Type"}
+        files = None
+        data = None
+        if file_data is not None:
+            files = {file_field: file_data}
+            data = {k: str(v) for k, v in fields.items() if v is not None}
+        else:
+            data = {k: str(v) for k, v in fields.items() if v is not None}
+        response = self._client.post(path, headers=headers, data=data, files=files)
+        _raise_for_status(response)
+        return response.json()
+
     def stream(self, path: str, body: Any) -> Iterator[ChatCompletionChunk]:
         with self._client.stream(
             "POST", path, json=body, headers=self._headers()
@@ -480,6 +497,23 @@ class AsyncHttpClient:
         response = await self._request("GET", path, params=params)
         return response.content
 
+    async def post_bytes(self, path: str, body: Any) -> bytes:
+        response = await self._request("POST", path, json_body=body)
+        return response.content
+
+    async def post_multipart(self, path: str, fields: Dict[str, Any], file_data: Optional[tuple] = None, file_field: str = "file") -> Any:
+        headers = {k: v for k, v in self._headers().items() if k != "Content-Type"}
+        files = None
+        data = None
+        if file_data is not None:
+            files = {file_field: file_data}
+            data = {k: str(v) for k, v in fields.items() if v is not None}
+        else:
+            data = {k: str(v) for k, v in fields.items() if v is not None}
+        response = await self._client.post(path, headers=headers, data=data, files=files)
+        _raise_for_status(response)
+        return response.json()
+
     async def stream(self, path: str, body: Any) -> AsyncIterator[ChatCompletionChunk]:
         async with self._client.stream(
             "POST", path, json=body, headers=self._headers()

{meshapi-0.1.4 → meshapi-0.1.6}/meshapi/_types.py

@@ -152,6 +152,7 @@ class ChatCompletionParams(BaseModel):
     seed: Optional[int] = None
     tools: Optional[List[Tool]] = None
     tool_choice: Optional[ToolChoice] = None
+    response_format: Optional[Dict[str, Any]] = None
 
     user: Optional[str] = None
     modality: Optional[Literal["text", "image"]] = None
@@ -160,6 +161,12 @@ class ChatCompletionParams(BaseModel):
     modalities: Optional[List[Literal["text", "audio"]]] = None
     audio: Optional[AudioOutputOptions] = None
 
+    # MeshAPI extension — overrides the server's 300 s upstream-provider timeout.
+    # Set this when your request may take longer than 5 minutes (e.g. long reasoning
+    # chains). The SDK-level timeout (MeshAPI(timeout=…)) is a separate HTTP-client
+    # timeout and does not affect this value.
+    timeout: Optional[float] = Field(default=None, gt=0)
+
 
 class UsageInfo(BaseModel):
     model_config = ConfigDict(extra="ignore")
@@ -399,6 +406,7 @@ class ResponsesParams(BaseModel):
     tool_choice: Optional[Union[str, Dict[str, Any]]] = None
     response_format: Optional[Dict[str, Any]] = None
     user: Optional[str] = Field(default=None, max_length=256)
+    timeout: Optional[float] = Field(default=None, gt=0)
 
 
 class ResponsesUsage(BaseModel):
@@ -616,6 +624,113 @@ class ImageGenerationChunk(BaseModel):
     model: Optional[str] = None
 
 
+# ---------------------------------------------------------------------------
+# Video
+# ---------------------------------------------------------------------------
+
+
+class VideoContentItem(BaseModel):
+    """A single item in the content array (text, image_url, video_url, audio_url)."""
+    model_config = ConfigDict(extra="ignore")
+    type: str
+    text: Optional[str] = None
+    image_url: Optional[Dict[str, Any]] = None
+    video_url: Optional[Dict[str, Any]] = None
+    audio_url: Optional[Dict[str, Any]] = None
+    draft_task: Optional[Dict[str, Any]] = None
+    role: Optional[str] = None
+
+
+class VideoGenerationParams(BaseModel):
+    """Request body for POST /v1/video/generations."""
+    model_config = ConfigDict(extra="ignore")
+    model: str
+    content: List[VideoContentItem]
+    callback_url: Optional[str] = None
+    return_last_frame: Optional[bool] = None
+    service_tier: Optional[str] = None
+    execution_expires_after: Optional[int] = None
+    generate_audio: Optional[bool] = None
+    draft: Optional[bool] = None
+    resolution: Optional[str] = None
+    ratio: Optional[str] = None
+    duration: Optional[int] = None
+    frames: Optional[int] = None
+    seed: Optional[int] = None
+    camera_fixed: Optional[bool] = None
+    watermark: Optional[bool] = None
+    safety_identifier: Optional[str] = None
+    priority: Optional[int] = None
+
+
+class CreateVideoGenerationResponse(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    id: str
+
+
+class VideoTaskError(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    code: str
+    message: str
+
+
+class VideoTaskContent(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    video_url: Optional[str] = None
+    last_frame_url: Optional[str] = None
+
+
+class VideoTaskUsage(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    completion_tokens: int
+    total_tokens: int
+
+
+class VideoTaskResponse(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    id: str
+    status: str
+    model: Optional[str] = None
+    error: Optional[VideoTaskError] = None
+    created_at: Optional[int] = None
+    updated_at: Optional[int] = None
+    content: Optional[VideoTaskContent] = None
+    seed: Optional[int] = None
+    resolution: Optional[str] = None
+    ratio: Optional[str] = None
+    duration: Optional[int] = None
+    frames: Optional[int] = None
+    framespersecond: Optional[int] = None
+    generate_audio: Optional[bool] = None
+    safety_identifier: Optional[str] = None
+    priority: Optional[int] = None
+    draft: Optional[bool] = None
+    draft_task_id: Optional[str] = None
+    service_tier: Optional[str] = None
+    execution_expires_after: Optional[int] = None
+    usage: Optional[VideoTaskUsage] = None
+
+
+class ListVideoGenerationsParams(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    status: Optional[str] = None
+    model: Optional[str] = None
+    created_after: Optional[str] = None
+    created_before: Optional[str] = None
+    limit: Optional[int] = None
+    offset: Optional[int] = None
+
+
+class VideoTaskListResponse(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    object: Optional[str] = None
+    data: List[VideoTaskResponse]
+    has_more: bool
+    total: int
+    limit: int
+    offset: int
+
+
 # ---------------------------------------------------------------------------
 
 # Error wire format
@@ -718,6 +833,126 @@ class SearchResponse(BaseModel):
     results: List[SearchResult]
 
 
+# ---------------------------------------------------------------------------
+# Audio
+# ---------------------------------------------------------------------------
+
+
+class VoiceSettings(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    stability: Optional[float] = None
+    similarity_boost: Optional[float] = None
+    style: Optional[float] = None
+    use_speaker_boost: Optional[bool] = None
+    speed: Optional[float] = None
+
+
+class PronunciationDictionaryLocator(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    pronunciation_dictionary_id: str
+    version_id: str
+
+
+class SpeechParams(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    input: str
+    model: Optional[str] = None
+    voice: Optional[str] = None
+    stream: Optional[bool] = None
+    response_format: Optional[str] = None
+    language_code: Optional[str] = None
+    voice_settings: Optional[VoiceSettings] = None
+    pronunciation_dictionary_locators: Optional[List[PronunciationDictionaryLocator]] = None
+    seed: Optional[int] = None
+    previous_text: Optional[str] = None
+    next_text: Optional[str] = None
+    previous_request_ids: Optional[List[str]] = None
+    next_request_ids: Optional[List[str]] = None
+    apply_text_normalization: Optional[str] = None
+    apply_language_text_normalization: Optional[bool] = None
+    use_pvc_as_ivc: Optional[bool] = None
+    enable_logging: Optional[bool] = None
+    optimize_streaming_latency: Optional[int] = None
+    speaker: Optional[str] = None
+    target_language_code: Optional[str] = None
+    pitch: Optional[float] = None
+    pace: Optional[float] = None
+    loudness: Optional[float] = None
+    speech_sample_rate: Optional[int] = None
+    enable_preprocessing: Optional[bool] = None
+
+
+class TranscriptionParams(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    model: str
+    language_code: Optional[str] = None
+    tag_audio_events: Optional[bool] = None
+    num_speakers: Optional[int] = None
+    timestamps_granularity: Optional[str] = None
+    diarize: Optional[bool] = None
+    diarization_threshold: Optional[float] = None
+    additional_formats: Optional[str] = None
+    file_format: Optional[str] = None
+    cloud_storage_url: Optional[str] = None
+    source_url: Optional[str] = None
+    webhook: Optional[bool] = None
+    webhook_id: Optional[str] = None
+    temperature: Optional[float] = None
+    seed: Optional[int] = None
+    use_multi_channel: Optional[bool] = None
+    webhook_metadata: Optional[str] = None
+    entity_detection: Optional[str] = None
+    no_verbatim: Optional[bool] = None
+    detect_speaker_roles: Optional[bool] = None
+    entity_redaction: Optional[str] = None
+    entity_redaction_mode: Optional[str] = None
+    keyterms: Optional[List[str]] = None
+    with_timestamps: Optional[bool] = None
+    debug_mode: Optional[bool] = None
+
+
+class TranscriptionTranslateParams(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    model: Optional[str] = None
+    prompt: Optional[str] = None
+
+
+class TranscriptionResponse(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    text: str
+
+
+class ListVoicesParams(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    next_page_token: Optional[str] = None
+    page_size: Optional[int] = None
+    search: Optional[str] = None
+    sort: Optional[str] = None
+    sort_direction: Optional[str] = None
+    voice_type: Optional[str] = None
+    category: Optional[str] = None
+    include_total_count: Optional[bool] = None
+    voice_ids: Optional[List[str]] = None
+
+
+class Voice(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    voice_id: str
+    name: str
+    category: str
+    description: str
+    preview_url: str
+    labels: Dict[str, str] = {}
+
+
+class VoicesResponse(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    voices: List[Voice]
+    has_more: bool
+    total_count: int
+    next_page_token: Optional[str] = None
+
+
 # ---------------------------------------------------------------------------
 
 class ApiErrorBody(BaseModel):

meshapi-0.1.6/meshapi/resources/audio.py

@@ -0,0 +1,140 @@
+"""Audio resource — /v1/audio/* endpoints."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from .._http import AsyncHttpClient, SyncHttpClient
+from .._types import (
+    ListVoicesParams,
+    SpeechParams,
+    TranscriptionParams,
+    TranscriptionResponse,
+    TranscriptionTranslateParams,
+    Voice,
+    VoicesResponse,
+)
+
+
+class AudioResource:
+    def __init__(self, http: SyncHttpClient) -> None:
+        self._http = http
+
+    def synthesize(self, params: SpeechParams) -> bytes:
+        """POST /v1/audio/speech — returns raw audio bytes."""
+        return self._http.post_bytes("/v1/audio/speech", params.model_dump(exclude_none=True))
+
+    def transcribe(
+        self,
+        file: bytes,
+        params: TranscriptionParams,
+        *,
+        filename: str = "audio.mp3",
+    ) -> TranscriptionResponse:
+        """POST /v1/audio/transcriptions — multipart upload."""
+        fields = params.model_dump(exclude_none=True)
+        data = self._http.post_multipart(
+            "/v1/audio/transcriptions",
+            fields,
+            file_data=(filename, file, "application/octet-stream"),
+            file_field="file",
+        )
+        return TranscriptionResponse.model_validate(data)
+
+    def get_transcription(self, transcription_id: str) -> Any:
+        """GET /v1/audio/transcriptions/{transcription_id}."""
+        return self._http.get(f"/v1/audio/transcriptions/{transcription_id}")
+
+    def translate(
+        self,
+        file: bytes,
+        params: Optional[TranscriptionTranslateParams] = None,
+        *,
+        filename: str = "audio.mp3",
+    ) -> TranscriptionResponse:
+        """POST /v1/audio/transcriptions/translate — multipart upload, translates to English."""
+        fields: Dict[str, Any] = {}
+        if params is not None:
+            fields = params.model_dump(exclude_none=True)
+        data = self._http.post_multipart(
+            "/v1/audio/transcriptions/translate",
+            fields,
+            file_data=(filename, file, "application/octet-stream"),
+            file_field="file",
+        )
+        return TranscriptionResponse.model_validate(data)
+
+    def list_voices(self, params: Optional[ListVoicesParams] = None) -> VoicesResponse:
+        """GET /v1/audio/voices — list/search voices."""
+        query: Dict[str, Any] = {}
+        if params is not None:
+            query = {k: v for k, v in params.model_dump(exclude_none=True).items()}
+        data = self._http.get("/v1/audio/voices", params=query or None)
+        return VoicesResponse.model_validate(data)
+
+    def get_voice(self, voice_id: str) -> Voice:
+        """GET /v1/audio/voices/{voice_id}."""
+        data = self._http.get(f"/v1/audio/voices/{voice_id}")
+        return Voice.model_validate(data)
+
+
+class AsyncAudioResource:
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+
+    async def synthesize(self, params: SpeechParams) -> bytes:
+        """POST /v1/audio/speech — returns raw audio bytes."""
+        return await self._http.post_bytes("/v1/audio/speech", params.model_dump(exclude_none=True))
+
+    async def transcribe(
+        self,
+        file: bytes,
+        params: TranscriptionParams,
+        *,
+        filename: str = "audio.mp3",
+    ) -> TranscriptionResponse:
+        """POST /v1/audio/transcriptions — multipart upload."""
+        fields = params.model_dump(exclude_none=True)
+        data = await self._http.post_multipart(
+            "/v1/audio/transcriptions",
+            fields,
+            file_data=(filename, file, "application/octet-stream"),
+            file_field="file",
+        )
+        return TranscriptionResponse.model_validate(data)
+
+    async def get_transcription(self, transcription_id: str) -> Any:
+        """GET /v1/audio/transcriptions/{transcription_id}."""
+        return await self._http.get(f"/v1/audio/transcriptions/{transcription_id}")
+
+    async def translate(
+        self,
+        file: bytes,
+        params: Optional[TranscriptionTranslateParams] = None,
+        *,
+        filename: str = "audio.mp3",
+    ) -> TranscriptionResponse:
+        """POST /v1/audio/transcriptions/translate — multipart upload, translates to English."""
+        fields: Dict[str, Any] = {}
+        if params is not None:
+            fields = params.model_dump(exclude_none=True)
+        data = await self._http.post_multipart(
+            "/v1/audio/transcriptions/translate",
+            fields,
+            file_data=(filename, file, "application/octet-stream"),
+            file_field="file",
+        )
+        return TranscriptionResponse.model_validate(data)
+
+    async def list_voices(self, params: Optional[ListVoicesParams] = None) -> VoicesResponse:
+        """GET /v1/audio/voices — list/search voices."""
+        query: Dict[str, Any] = {}
+        if params is not None:
+            query = {k: v for k, v in params.model_dump(exclude_none=True).items()}
+        data = await self._http.get("/v1/audio/voices", params=query or None)
+        return VoicesResponse.model_validate(data)
+
+    async def get_voice(self, voice_id: str) -> Voice:
+        """GET /v1/audio/voices/{voice_id}."""
+        data = await self._http.get(f"/v1/audio/voices/{voice_id}")
+        return Voice.model_validate(data)

meshapi-0.1.6/meshapi/resources/videos.py

@@ -0,0 +1,57 @@
+"""Videos resource — /v1/video/generations endpoints."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .._http import AsyncHttpClient, SyncHttpClient
+from .._types import (
+    CreateVideoGenerationResponse,
+    ListVideoGenerationsParams,
+    VideoGenerationParams,
+    VideoTaskListResponse,
+    VideoTaskResponse,
+)
+
+
+class VideosResource:
+    def __init__(self, http: SyncHttpClient) -> None:
+        self._http = http
+
+    def generate(self, params: VideoGenerationParams) -> CreateVideoGenerationResponse:
+        """POST /v1/video/generations — submit a video generation task."""
+        data = self._http.post("/v1/video/generations", params.model_dump(exclude_none=True))
+        return CreateVideoGenerationResponse.model_validate(data)
+
+    def list(self, params: Optional[ListVideoGenerationsParams] = None) -> VideoTaskListResponse:
+        """GET /v1/video/generations — list video generation tasks."""
+        query = None
+        if params is not None:
+            query = {k: str(v) for k, v in params.model_dump(exclude_none=True).items()} or None
+        data = self._http.get("/v1/video/generations", params=query)
+        return VideoTaskListResponse.model_validate(data)
+
+    def retrieve(self, task_id: str) -> VideoTaskResponse:
+        """GET /v1/video/generations/{task_id} — get a video generation task."""
+        data = self._http.get(f"/v1/video/generations/{task_id}")
+        return VideoTaskResponse.model_validate(data)
+
+
+class AsyncVideosResource:
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+
+    async def generate(self, params: VideoGenerationParams) -> CreateVideoGenerationResponse:
+        data = await self._http.post("/v1/video/generations", params.model_dump(exclude_none=True))
+        return CreateVideoGenerationResponse.model_validate(data)
+
+    async def list(self, params: Optional[ListVideoGenerationsParams] = None) -> VideoTaskListResponse:
+        query = None
+        if params is not None:
+            query = {k: str(v) for k, v in params.model_dump(exclude_none=True).items()} or None
+        data = await self._http.get("/v1/video/generations", params=query)
+        return VideoTaskListResponse.model_validate(data)
+
+    async def retrieve(self, task_id: str) -> VideoTaskResponse:
+        data = await self._http.get(f"/v1/video/generations/{task_id}")
+        return VideoTaskResponse.model_validate(data)

{meshapi-0.1.4 → meshapi-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meshapi"
-version = "0.1.4"
+version = "0.1.6"
 description = "Official Python SDK for the MeshAPI AI model gateway"
 readme = "README.md"
 requires-python = ">=3.9"