meshapi 0.1.0__tar.gz → 0.1.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshapi
-Version: 0.1.0
+Version: 0.1.3
 Summary: Official Python SDK for the MeshAPI AI model gateway
 Project-URL: Homepage, https://meshapi.ai
 Project-URL: Documentation, https://developers.meshapi.ai
@@ -85,28 +85,15 @@ Get a key at [meshapi.ai](https://meshapi.ai). Data-plane keys are prefixed `rsk
 | **Structured errors** | `MeshAPIError` with `error_code`, `status`, `request_id`, `retry_after_seconds`, and provider error details. |
 | **Type-safe** | Every request and response is a Pydantic v2 model. Autocomplete in your editor, validation at the boundary. |
 
-## Configuration
+## Authentication
+
+The SDK requires a Mesh API key (prefixed with `rsk_`) for all requests. You can obtain a key at [meshapi.ai](https://meshapi.ai).
 
 ```python
-client = MeshAPI(
-    base_url="https://api.meshapi.ai",  # required
-    token="rsk_...",                     # required: data-plane key or Supabase JWT
-    timeout=60.0,                        # default 60s
-    max_retries=3,                       # default 3, set 0 to disable
-    httpx_client=None,                   # optional: inject a custom httpx.Client
-)
+client = MeshAPI(base_url="https://api.meshapi.ai", token="rsk_...")
 ```
 
-`AsyncMeshAPI` takes the same arguments (with `async_httpx_client` instead of `httpx_client`) and supports `async with` for clean shutdown.
-
-Two auth realms. Use one client per realm.
-
-| Realm | Token | Resources |
-|---|---|---|
-| **Data-plane** | `rsk_<ULID>` | `chat`, `responses`, `embeddings`, `compare`, `files`, `batches` |
-| **Control-plane** | Supabase JWT | `templates`, `models` |
-
-`models` accepts either token type.
+This key provides access to all resources: `chat`, `responses`, `embeddings`, `compare`, `files`, `batches`, `models`, and `templates`.
 
 ## Chat completions
 
@@ -240,6 +227,25 @@ result = client.embeddings.create(
 print(len(result.data[0].embedding))
 ```
 
+## Image Generation
+
+```python
+from meshapi import ImageGenerationParams
+
+result = client.images.generate(
+    ImageGenerationParams(
+        model="openai/gpt-image-1",
+        prompt="A watercolor of a fox in a snowy forest",
+        n=1,
+        size="1024x1024",
+        quality="high",
+        output_format="webp",
+    )
+)
+
+print(result.data[0].url)
+```
+
 ## Compare (multi-model fanout)
 
 Fire one prompt at several models and stream their replies in parallel.
@@ -339,10 +345,10 @@ Server-stored prompts with `{{variable}}` interpolation. Reference them by name
 ```python
 from meshapi import MeshAPI, CreateTemplateParams, ChatCompletionParams, ChatMessage
 
-# Manage templates with a control-plane JWT
-ctrl = MeshAPI(base_url="https://api.meshapi.ai", token=supabase_session_jwt)
+# Manage templates with either a data-plane key or control-plane JWT
+client = MeshAPI(base_url="https://api.meshapi.ai", token="rsk_...")
 
-ctrl.templates.create(
+client.templates.create(
     CreateTemplateParams(
         name="support-agent",
         system="You are a support agent for {{company}}. Be concise and friendly.",
@@ -351,9 +357,6 @@ ctrl.templates.create(
     )
 )
 
-# Use the template with a data-plane rsk_ key
-client = MeshAPI(base_url="https://api.meshapi.ai", token="rsk_...")
-
 reply = client.chat.completions.create(
     ChatCompletionParams(
         messages=[ChatMessage(role="user", content="How do I reset my password?")],

{meshapi-0.1.0 → meshapi-0.1.3}/README.md

@@ -51,28 +51,15 @@ Get a key at [meshapi.ai](https://meshapi.ai). Data-plane keys are prefixed `rsk
 | **Structured errors** | `MeshAPIError` with `error_code`, `status`, `request_id`, `retry_after_seconds`, and provider error details. |
 | **Type-safe** | Every request and response is a Pydantic v2 model. Autocomplete in your editor, validation at the boundary. |
 
-## Configuration
+## Authentication
+
+The SDK requires a Mesh API key (prefixed with `rsk_`) for all requests. You can obtain a key at [meshapi.ai](https://meshapi.ai).
 
 ```python
-client = MeshAPI(
-    base_url="https://api.meshapi.ai",  # required
-    token="rsk_...",                     # required: data-plane key or Supabase JWT
-    timeout=60.0,                        # default 60s
-    max_retries=3,                       # default 3, set 0 to disable
-    httpx_client=None,                   # optional: inject a custom httpx.Client
-)
+client = MeshAPI(base_url="https://api.meshapi.ai", token="rsk_...")
 ```
 
-`AsyncMeshAPI` takes the same arguments (with `async_httpx_client` instead of `httpx_client`) and supports `async with` for clean shutdown.
-
-Two auth realms. Use one client per realm.
-
-| Realm | Token | Resources |
-|---|---|---|
-| **Data-plane** | `rsk_<ULID>` | `chat`, `responses`, `embeddings`, `compare`, `files`, `batches` |
-| **Control-plane** | Supabase JWT | `templates`, `models` |
-
-`models` accepts either token type.
+This key provides access to all resources: `chat`, `responses`, `embeddings`, `compare`, `files`, `batches`, `models`, and `templates`.
 
 ## Chat completions
 
@@ -206,6 +193,25 @@ result = client.embeddings.create(
 print(len(result.data[0].embedding))
 ```
 
+## Image Generation
+
+```python
+from meshapi import ImageGenerationParams
+
+result = client.images.generate(
+    ImageGenerationParams(
+        model="openai/gpt-image-1",
+        prompt="A watercolor of a fox in a snowy forest",
+        n=1,
+        size="1024x1024",
+        quality="high",
+        output_format="webp",
+    )
+)
+
+print(result.data[0].url)
+```
+
 ## Compare (multi-model fanout)
 
 Fire one prompt at several models and stream their replies in parallel.
@@ -305,10 +311,10 @@ Server-stored prompts with `{{variable}}` interpolation. Reference them by name
 ```python
 from meshapi import MeshAPI, CreateTemplateParams, ChatCompletionParams, ChatMessage
 
-# Manage templates with a control-plane JWT
-ctrl = MeshAPI(base_url="https://api.meshapi.ai", token=supabase_session_jwt)
+# Manage templates with either a data-plane key or control-plane JWT
+client = MeshAPI(base_url="https://api.meshapi.ai", token="rsk_...")
 
-ctrl.templates.create(
+client.templates.create(
     CreateTemplateParams(
         name="support-agent",
         system="You are a support agent for {{company}}. Be concise and friendly.",
@@ -317,9 +323,6 @@ ctrl.templates.create(
     )
 )
 
-# Use the template with a data-plane rsk_ key
-client = MeshAPI(base_url="https://api.meshapi.ai", token="rsk_...")
-
 reply = client.chat.completions.create(
     ChatCompletionParams(
         messages=[ChatMessage(role="user", content="How do I reset my password?")],

{meshapi-0.1.0 → meshapi-0.1.3}/TESTING.md

@@ -55,10 +55,10 @@ MESHAPI_BASE_URL=http://localhost:8000 MESHAPI_TOKEN=your_rsk_key pytest tests/i
 
 ## 3. Live Tests (Standalone)
 
-Located in the separate `meshapi-python-livetest/` directory. These are standalone scripts designed for quick, manual verification of the SDK against a live server.
+Located in the separate `meshapi-sdk-livetest/` directory. These are standalone scripts designed for quick, manual verification of the SDK against a live server.
 
 **To run live tests:**
-1. Navigate to the directory: `cd ../meshapi-python-livetest`
+1. Navigate to the directory: `cd ../meshapi-sdk-livetest`
 2. Configure the server and token in `config.py`.
 3. Run individual scripts:
 ```bash

meshapi-0.1.3/livetests/batch_file.py

@@ -0,0 +1,61 @@
+from meshapi import (
+    UploadBatchFileParams,
+    BatchRequestItem,
+    CreateBatchParams,
+)
+from meshapi import CompareParams, ChatMessage
+from meshapi import (
+    ChatCompletionParams,
+    ChatMessage,
+    Tool,
+    ToolFunction,
+    MeshAPI,
+    MeshAPIError,
+)
+from config import BASE_URL, TOKEN
+
+client = MeshAPI(base_url=BASE_URL, token=TOKEN)
+
+
+# 1. Upload the batch input
+# file = client.files.upload(
+#     UploadBatchFileParams(
+#         purpose="batch",
+#         requests=[
+#             BatchRequestItem(
+#                 custom_id="req-1",
+#                 body={
+#                     "model": "openai/gpt-4.1-mini",
+#                     "messages": [{"role": "user", "content": "Say hi."}],
+#                 },
+#             ),
+#             BatchRequestItem(
+#                 custom_id="req-2",
+#                 body={
+#                     "model": "openai/gpt-4.1-mini",
+#                     "messages": [{"role": "user", "content": "Say bye."}],
+#                 },
+#             ),
+#         ],
+#     )
+# )
+
+# 2. Create the batch
+# batch = client.batches.create(
+#     CreateBatchParams(
+#         input_file_id=file.id,
+#         endpoint="/v1/chat/completions",
+#         completion_window="24h",
+#     )
+# )
+
+# print("batch id is: ", batch.id)
+
+# 3. Poll later
+status = client.batches.get("batch_6a038d038ad481908c22ced67b7001c1")
+print("batch status is: ", status)
+
+if status.status == "completed" and status.output_file_id:
+    output_bytes = client.files.content(status.output_file_id)
+    print(output_bytes)
+    # output_bytes is JSONL

meshapi-0.1.3/livetests/compare.py

@@ -0,0 +1,34 @@
+from meshapi import CompareParams, ChatMessage
+from meshapi import (
+    ChatCompletionParams,
+    ChatMessage,
+    Tool,
+    ToolFunction,
+    MeshAPI,
+    MeshAPIError,
+)
+from config import BASE_URL, TOKEN
+
+client = MeshAPI(base_url=BASE_URL, token=TOKEN)
+
+stream = client.compare.stream(
+    CompareParams(
+        models=[
+            # "openai/gpt-4o-mini",
+            # "anthropic/claude-sonnet-4.5",
+            "google/gemini-2.5-flash",
+            "openai/gpt-4o",
+        ],
+        messages=[
+            ChatMessage(
+                role="user", content="Summarize this paragraph in one sentence: ..."
+            )
+        ],
+        stream=True,
+    )
+)
+
+for event in stream:
+    print(event)
+    if event.delta:
+        print(event.delta, end="", flush=True)

meshapi-0.1.3/livetests/config.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+
+SDK_ROOT = Path(__file__).resolve().parents[1]
+if str(SDK_ROOT) not in sys.path:
+    sys.path.insert(0, str(SDK_ROOT))
+
+
+def _load_shared_env() -> dict[str, str]:
+    env_path = Path(__file__).resolve().parents[1] / ".env.livetest"
+    if not env_path.exists():
+        env_path = Path(__file__).resolve().parents[2] / ".env.livetest"
+    
+    values: dict[str, str] = {}
+    if not env_path.exists():
+        return values
+
+
+    for raw_line in env_path.read_text().splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        key = key.strip()
+        value = value.strip().strip('"').strip("'")
+        if key:
+            values[key] = value
+    return values
+
+
+_SHARED_ENV = _load_shared_env()
+
+BASE_URL = os.getenv("MESHAPI_BASE_URL") or _SHARED_ENV.get("MESHAPI_BASE_URL", "http://localhost:8000")
+TOKEN = os.getenv("MESHAPI_TOKEN") or _SHARED_ENV.get("MESHAPI_TOKEN", "rsk_01KN96KQWDPF2X1E9CP8567JY4")
+MODEL = os.getenv("MESHAPI_MODEL") or _SHARED_ENV.get("MESHAPI_MODEL", "openai/gpt-4o-mini")
+
+
+def get_env(name: str, default: str | None = None) -> str | None:
+    return os.getenv(name) or _SHARED_ENV.get(name, default)

meshapi-0.1.3/livetests/conftest.py

@@ -0,0 +1,93 @@
+"""
+pytest conftest for the MeshAPI Python live-test suite.
+
+Registers shared fixtures so every test_*.py file can import
+`client`, `model`, and helpers directly without touching config.py.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import time
+from pathlib import Path
+
+import pytest
+
+# ---------------------------------------------------------------------------
+# Make sure the local SDK is importable even when running via pytest from CI
+# (the requirements.txt already does `pip install -e ../meshapi-python-sdk`,
+#  but this is a safety net for non-venv runs).
+# ---------------------------------------------------------------------------
+SDK_ROOT = Path(__file__).resolve().parents[1]
+if str(SDK_ROOT) not in sys.path:
+    sys.path.insert(0, str(SDK_ROOT))
+
+# ---------------------------------------------------------------------------
+# Import after sys.path is set up
+# ---------------------------------------------------------------------------
+from config import BASE_URL, TOKEN, MODEL, get_env  # noqa: E402
+from meshapi import MeshAPI  # noqa: E402
+
+
+# ---------------------------------------------------------------------------
+# Session-scoped shared client fixture
+# ---------------------------------------------------------------------------
+
+@pytest.fixture(scope="session")
+def client() -> MeshAPI:
+    """Return a single MeshAPI client reused for all tests in the session."""
+    return MeshAPI(base_url=BASE_URL, token=TOKEN)
+
+
+@pytest.fixture(scope="session")
+def model() -> str:
+    return MODEL
+
+
+@pytest.fixture(scope="session")
+def embeddings_model() -> str:
+    return get_env("MESHAPI_EMBEDDINGS_MODEL", "openai/text-embedding-3-small")
+
+
+
+@pytest.fixture(scope="session")
+def second_model() -> str:
+    """A second distinct model for compare tests. Defaults to a different model from MODEL."""
+    default = "anthropic/claude-haiku-4-5" if MODEL == "openai/gpt-4o-mini" else "openai/gpt-4o-mini"
+    return get_env("MESHAPI_SECOND_MODEL", default)
+
+
+@pytest.fixture(scope="session")
+def image_url() -> str | None:
+    return get_env("MESHAPI_IMAGE_URL")
+
+
+@pytest.fixture(scope="session")
+def audio_b64() -> str | None:
+    return get_env("MESHAPI_INPUT_AUDIO_B64")
+
+
+@pytest.fixture(scope="session")
+def audio_format() -> str:
+    return get_env("MESHAPI_INPUT_AUDIO_FORMAT", "wav")
+
+
+@pytest.fixture(scope="session")
+def audio_out_model() -> str | None:
+    return get_env("MESHAPI_AUDIO_OUT_MODEL")
+
+
+@pytest.fixture(scope="session")
+def image_gen_model() -> str | None:
+    return get_env("MESHAPI_IMAGE_GEN_MODEL")
+
+
+# ---------------------------------------------------------------------------
+# Helpers available as fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture(scope="session")
+def unique_tag() -> str:
+    """A stable unique tag for the entire test session (e.g. for file uploads)."""
+    return f"ci-{int(time.time())}"

meshapi-0.1.3/livetests/pytest.ini

@@ -0,0 +1,16 @@
+[pytest]
+# Discover all live-test files in this directory
+testpaths = .
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+
+# Never import from parent packages accidentally
+addopts =
+    --tb=short
+    --no-header
+    -v
+
+# Treat warnings as informational only during live tests
+filterwarnings =
+    ignore::DeprecationWarning

meshapi-0.1.3/livetests/requirements.txt

@@ -0,0 +1,2 @@
+-e ..[dev]
+pytest>=8.0.0

meshapi-0.1.3/livetests/responses.py

@@ -0,0 +1,23 @@
+from meshapi import ResponsesParams
+from meshapi import (
+    ChatCompletionParams,
+    ChatMessage,
+    Tool,
+    ToolFunction,
+    MeshAPI,
+    MeshAPIError,
+)
+from config import BASE_URL, TOKEN
+
+client = MeshAPI(base_url=BASE_URL, token=TOKEN)
+
+reply = client.responses.create(
+    ResponsesParams(
+        model="openai/o4-mini",
+        input="Explain the halting problem in two sentences.",
+        reasoning={"effort": "medium"},
+        max_output_tokens=512,
+    )
+)
+
+print(reply.output)

meshapi-0.1.3/livetests/test_chat.py

@@ -0,0 +1,83 @@
+"""Live tests: Chat completions (non-streaming)."""
+
+from __future__ import annotations
+
+import pytest
+from meshapi import MeshAPI, ChatCompletionParams, ChatMessage
+from meshapi._types import CreateTemplateParams
+
+
+def test_chat_basic(client: MeshAPI, model: str) -> None:
+    resp = client.chat.completions.create(
+        ChatCompletionParams(
+            model=model,
+            messages=[ChatMessage(role="user", content="What is the capital of France? Reply in one word.")],
+            max_tokens=10,
+            temperature=0,
+        )
+    )
+    content = resp.choices[0].message.content
+    role = resp.choices[0].message.role
+    assert role == "assistant", f"expected role 'assistant', got {role!r}"
+    assert content, "expected non-empty content"
+
+
+def test_chat_multi_turn(client: MeshAPI, model: str) -> None:
+    resp = client.chat.completions.create(
+        ChatCompletionParams(
+            model=model,
+            messages=[
+                ChatMessage(role="user", content="My favourite color is blue. Remember this."),
+                ChatMessage(role="assistant", content="Got it! Your favourite color is blue."),
+                ChatMessage(role="user", content="What is my favourite color? Reply in 3 words max."),
+            ],
+            max_tokens=20,
+            temperature=0,
+        )
+    )
+    content = resp.choices[0].message.content
+    assert content, "expected non-empty content in multi-turn response"
+    assert resp.choices[0].finish_reason in ("stop", "length")
+
+
+def test_chat_with_template(client: MeshAPI, model: str) -> None:
+    import uuid
+
+    name = f"py-livetest-chat-{uuid.uuid4().hex[:8]}"
+    tmpl = client.templates.create(
+        CreateTemplateParams(
+            name=name,
+            system="You are a {{role}}. Always reply in exactly one sentence.",
+            variables=["role"],
+        )
+    )
+    try:
+        resp = client.chat.completions.create(
+            ChatCompletionParams(
+                model=model,
+                messages=[ChatMessage(role="user", content="Introduce yourself.")],
+                template=tmpl.name,
+                variables={"role": "friendly pirate"},
+                max_tokens=80,
+                temperature=0,
+            )
+        )
+        content = resp.choices[0].message.content
+        assert content, "expected non-empty templated chat response"
+    finally:
+        client.templates.delete(tmpl.id)
+
+
+def test_chat_response_fields(client: MeshAPI, model: str) -> None:
+    resp = client.chat.completions.create(
+        ChatCompletionParams(
+            model=model,
+            messages=[ChatMessage(role="user", content="Say hello.")],
+            max_tokens=10,
+        )
+    )
+    assert resp.id, "response should have an id"
+    assert resp.model, "response should have a model field"
+    assert resp.usage is not None, "response should include usage"
+    assert resp.choices, "response should have choices"
+    assert resp.choices[0].message.role == "assistant"

meshapi-0.1.3/livetests/test_errors.py

@@ -0,0 +1,45 @@
+"""Live tests: error handling and exception types."""
+
+from __future__ import annotations
+
+import pytest
+from meshapi import MeshAPI, MeshAPIError, ChatCompletionParams, ChatMessage
+from config import BASE_URL
+
+
+def test_error_unauthorized_chat(model: str) -> None:
+    bad = MeshAPI(base_url=BASE_URL, token="rsk_INVALID_TOKEN")
+    with pytest.raises(MeshAPIError) as exc_info:
+        bad.chat.completions.create(
+            ChatCompletionParams(
+                model=model,
+                messages=[ChatMessage(role="user", content="hello")],
+            )
+        )
+    err = exc_info.value
+    assert err.status == 401
+    assert err.error_code, "expected an error_code in the response"
+
+
+def test_error_unauthorized_models() -> None:
+    bad = MeshAPI(base_url=BASE_URL, token="rsk_INVALID_TOKEN")
+    with pytest.raises(MeshAPIError) as exc_info:
+        bad.models.list()
+    assert exc_info.value.status == 401
+
+
+def test_error_not_found_template(client: MeshAPI) -> None:
+    with pytest.raises(MeshAPIError) as exc_info:
+        client.templates.get("tmpl_nonexistent_id_000000")
+    assert exc_info.value.status == 404
+
+
+def test_error_is_exception(model: str) -> None:
+    bad = MeshAPI(base_url=BASE_URL, token="rsk_INVALID_TOKEN")
+    with pytest.raises(Exception):
+        bad.chat.completions.create(
+            ChatCompletionParams(
+                model=model,
+                messages=[ChatMessage(role="user", content="hello")],
+            )
+        )