mira-network 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

{mira_sdk → mira_network}/__init__.py

@@ -1,12 +1,10 @@
 from .client import MiraClient
+from .sync_client import MiraSyncClient
 from .models import (
     Message,
     ModelProvider,
     AiRequest,
-    FlowChatCompletion,
-    FlowRequest,
     ApiTokenRequest,
-    AddCreditRequest,
 )
 
 __all__ = [
@@ -14,8 +12,5 @@ __all__ = [
     "Message",
     "ModelProvider",
     "AiRequest",
-    "FlowChatCompletion",
-    "FlowRequest",
     "ApiTokenRequest",
-    "AddCreditRequest",
 ]

mira_network/client.py

@@ -0,0 +1,173 @@
+from typing import AsyncIterator, Optional, List, Dict, AsyncGenerator, Union
+import httpx
+from .models import (
+    AiRequest,
+    ApiTokenRequest,
+)
+
+
+class MiraClient:
+
+    def __init__(
+        self,
+        base_url: str = "https://apis.mira.network/",
+        api_token: Optional[str] = None,
+    ):
+        """Initialize Mira client.
+
+        Args:
+            base_url: Base URL of the Mira API
+            api_token: Optional API token for authentication
+        """
+        self.base_url = base_url
+        self.api_token = api_token
+        self._client = httpx.AsyncClient()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self._client.aclose()
+
+    def _get_headers(self) -> Dict[str, str]:
+        headers = {"Content-Type": "application/json"}
+        if self.api_token:
+            headers["Authorization"] = f"Bearer {self.api_token}"
+        return headers
+
+    async def list_models(self) -> List[str]:
+        """List available models."""
+        response = await self._client.get(
+            f"{self.base_url}/v1/models",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    async def generate(self, request: AiRequest) -> Union[str, AsyncIterator[str]]:
+        """Generate text using the specified model."""
+        response = await self._client.post(
+            f"{self.base_url}/v1/chat/completions",
+            headers=self._get_headers(),
+            json=request.model_dump(),
+        )
+
+        response.raise_for_status()
+
+        if request.stream:
+            return response.aiter_lines()
+        else:
+            return response.json()
+
+    # async def generate_with_flow(
+    #     self, flow_id: str, request: FlowChatCompletion
+    # ) -> Union[str, AsyncGenerator[str, None]]:
+    #     """Generate text using a specific flow."""
+    #     response = await self._client.post(
+    #         f"{self.base_url}/v1/flows/{flow_id}/chat/completions",
+    #         headers=self._get_headers(),
+    #         json=request.model_dump(),
+    #     )
+    #     response.raise_for_status()
+    #     return response.json()
+
+    # async def list_flows(self) -> List[Dict]:
+    #     """List all flows."""
+    #     response = await self._client.get(
+    #         f"{self.base_url}/flows",
+    #         headers=self._get_headers(),
+    #     )
+    #     response.raise_for_status()
+    #     return response.json()
+
+    # async def get_flow(self, flow_id: str) -> Dict:
+    #     """Get details of a specific flow."""
+    #     response = await self._client.get(
+    #         f"{self.base_url}/flows/{flow_id}",
+    #         headers=self._get_headers(),
+    #     )
+    #     response.raise_for_status()
+    #     return response.json()
+
+    # async def create_flow(self, request: FlowRequest) -> Dict:
+    #     """Create a new flow."""
+    #     response = await self._client.post(
+    #         f"{self.base_url}/flows",
+    #         headers=self._get_headers(),
+    #         json=request.model_dump(),
+    #     )
+    #     response.raise_for_status()
+    #     return response.json()
+
+    # async def update_flow(self, flow_id: str, request: FlowRequest) -> Dict:
+    #     """Update an existing flow."""
+    #     response = await self._client.put(
+    #         f"{self.base_url}/flows/{flow_id}",
+    #         headers=self._get_headers(),
+    #         json=request.model_dump(),
+    #     )
+    #     response.raise_for_status()
+    #     return response.json()
+
+    # async def delete_flow(self, flow_id: str) -> None:
+    #     """Delete a flow."""
+    #     response = await self._client.delete(
+    #         f"{self.base_url}/flows/{flow_id}",
+    #         headers=self._get_headers(),
+    #     )
+    #     response.raise_for_status()
+
+    async def create_api_token(self, request: ApiTokenRequest) -> Dict:
+        """Create a new API token."""
+        response = await self._client.post(
+            f"{self.base_url}/api-tokens",
+            headers=self._get_headers(),
+            json=request.model_dump(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    async def list_api_tokens(self) -> List[Dict]:
+        """List all API tokens."""
+        response = await self._client.get(
+            f"{self.base_url}/api-tokens",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    async def delete_api_token(self, token: str) -> None:
+        """Delete an API token."""
+        response = await self._client.delete(
+            f"{self.base_url}/api-tokens/{token}",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+
+    async def get_user_credits(self) -> Dict:
+        """Get user credits information."""
+        response = await self._client.get(
+            f"{self.base_url}/user-credits",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    # async def add_credit(self, request: AddCreditRequest) -> Dict:
+    #     """Add credits to a user account."""
+    #     response = await self._client.post(
+    #         f"{self.base_url}/credits",
+    #         headers=self._get_headers(),
+    #         json=request.model_dump(),
+    #     )
+    #     response.raise_for_status()
+    #     return response.json()
+
+    async def get_credits_history(self) -> List[Dict]:
+        """Get user credits history."""
+        response = await self._client.get(
+            f"{self.base_url}/user-credits-history",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()

{mira_sdk → mira_network}/models.py

@@ -22,7 +22,9 @@ class ModelProvider(BaseModel):
 
 class AiRequest(BaseModel):
     model: str = Field("mira/llama3.1", title="Model")
-    model_provider: Optional[ModelProvider] = Field(None, title="Model Provider (optional)")
+    model_provider: Optional[ModelProvider] = Field(
+        None, title="Model Provider (optional)"
+    )
     messages: List[Message] = Field([], title="Messages")
     stream: Optional[bool] = Field(False, title="Stream")
 
@@ -34,34 +36,34 @@ class AiRequest(BaseModel):
         return v
 
 
-class FlowChatCompletion(BaseModel):
-    variables: Optional[Dict] = Field(None, title="Variables")
+# class FlowChatCompletion(BaseModel):
+#     variables: Optional[Dict] = Field(None, title="Variables")
 
 
-class FlowRequest(BaseModel):
-    system_prompt: str
-    name: str
+# class FlowRequest(BaseModel):
+#     system_prompt: str
+#     name: str
 
 
 class ApiTokenRequest(BaseModel):
     description: Optional[str] = None
 
 
-class AddCreditRequest(BaseModel):
-    user_id: str
-    amount: float
-    description: Optional[str] = None
-
-    @field_validator("amount")
-    @classmethod
-    def validate_amount(cls, v: float) -> float:
-        if v <= 0:
-            raise ValueError("Amount must be greater than 0")
-        return v
-
-    @field_validator("user_id")
-    @classmethod
-    def validate_user_id(cls, v: str) -> str:
-        if not v.strip():
-            raise ValueError("User ID cannot be empty")
-        return v
+# class AddCreditRequest(BaseModel):
+#     user_id: str
+#     amount: float
+#     description: Optional[str] = None
+
+#     @field_validator("amount")
+#     @classmethod
+#     def validate_amount(cls, v: float) -> float:
+#         if v <= 0:
+#             raise ValueError("Amount must be greater than 0")
+#         return v
+
+#     @field_validator("user_id")
+#     @classmethod
+#     def validate_user_id(cls, v: str) -> str:
+#         if not v.strip():
+#             raise ValueError("User ID cannot be empty")
+#         return v

mira_network/sync_client.py

@@ -0,0 +1,111 @@
+from typing import Optional, List, Dict, Iterator, Union
+import requests
+from .models import (
+    AiRequest,
+    ApiTokenRequest,
+)
+
+
+class MiraSyncClient:
+    def __init__(
+        self,
+        base_url: str = "https://apis.mira.network/",
+        api_token: Optional[str] = None,
+    ):
+        """Initialize Mira synchronous client.
+
+        Args:
+            base_url: Base URL of the Mira API
+            api_token: Optional API token for authentication
+        """
+        self.base_url = base_url
+        self.api_token = api_token
+        self._session = requests.Session()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._session.close()
+
+    def _get_headers(self) -> Dict[str, str]:
+        headers = {"Content-Type": "application/json"}
+        if self.api_token:
+            headers["Authorization"] = f"Bearer {self.api_token}"
+        return headers
+
+    def list_models(self) -> List[str]:
+        """List available models."""
+        response = self._session.get(
+            f"{self.base_url}/v1/models",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def generate(self, request: AiRequest) -> Union[str, Iterator[str]]:
+        """Generate text using the specified model.
+
+        Args:
+            request: The AI request configuration
+
+        Returns:
+            Either a string response (when stream=False) or an iterator of string chunks (when stream=True)
+        """
+        response = self._session.post(
+            f"{self.base_url}/v1/chat/completions",
+            headers=self._get_headers(),
+            json=request.model_dump(),
+            stream=request.stream,
+        )
+        response.raise_for_status()
+
+        if request.stream:
+            return response.iter_lines(decode_unicode=True)
+        else:
+            return response.json()
+
+    def create_api_token(self, request: ApiTokenRequest) -> Dict:
+        """Create a new API token."""
+        response = self._session.post(
+            f"{self.base_url}/api-tokens",
+            headers=self._get_headers(),
+            json=request.model_dump(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def list_api_tokens(self) -> List[Dict]:
+        """List all API tokens."""
+        response = self._session.get(
+            f"{self.base_url}/api-tokens",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def delete_api_token(self, token: str) -> None:
+        """Delete an API token."""
+        response = self._session.delete(
+            f"{self.base_url}/api-tokens/{token}",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+
+    def get_user_credits(self) -> Dict:
+        """Get user credits information."""
+        response = self._session.get(
+            f"{self.base_url}/user-credits",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def get_credits_history(self) -> List[Dict]:
+        """Get user credits history."""
+        response = self._session.get(
+            f"{self.base_url}/user-credits-history",
+            headers=self._get_headers(),
+        )
+        response.raise_for_status()
+        return response.json()

mira_network-0.1.4.dist-info/METADATA

@@ -0,0 +1,178 @@
+Metadata-Version: 2.1
+Name: mira-network
+Version: 0.1.4
+Summary: Python SDK for Mira Network API
+Author-Email: sarim2000 <sarimbleedblue@gmail.com>
+License: MIT
+Requires-Python: ==3.10.*
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.10.4
+Requires-Dist: typing-extensions>=4.8.0
+Requires-Dist: requests>=2.32.3
+Requires-Dist: pytest-cov>=6.0.0
+Description-Content-Type: text/markdown
+
+# Mira Network SDK
+
+A Python SDK for interacting with the Mira Network API. This SDK provides both synchronous and asynchronous interfaces to access Mira API endpoints for model inference, API token management, and credit system operations.
+
+## Installation
+
+```bash
+pip install mira-network
+```
+
+## Quick Start
+
+### Synchronous Usage
+
+```python
+from mira_network.sync_client import MiraSyncClient
+from mira_network.models import AiRequest, Message
+
+# Using context manager (recommended)
+with MiraSyncClient(api_token="your-api-token") as client:
+    # Example 1: Non-streaming response
+    request = AiRequest(
+        messages=[
+            Message(role="system", content="You are a helpful assistant."),
+            Message(role="user", content="Hello!")
+        ],
+        stream=False
+    )
+    response = client.generate(request)
+    print(response)
+    
+    # Example 2: Streaming response
+    stream_request = AiRequest(
+        messages=[
+            Message(role="system", content="You are a helpful assistant."),
+            Message(role="user", content="Tell me a story!")
+        ],
+        stream=True
+    )
+    for chunk in client.generate(stream_request):
+        print(chunk)
+```
+
+### Asynchronous Usage
+
+```python
+import asyncio
+from mira_network.client import MiraClient
+from mira_network.models import AiRequest, Message
+
+async def main():
+    # Using async context manager (recommended)
+    async with MiraClient(api_token="your-api-token") as client:
+        # Example 1: Non-streaming response
+        request = AiRequest(
+            messages=[
+                Message(role="system", content="You are a helpful assistant."),
+                Message(role="user", content="Hello!")
+            ],
+            stream=False
+        )
+        response = await client.generate(request)
+        print(response)
+        
+        # Example 2: Streaming response
+        stream_request = AiRequest(
+            messages=[
+                Message(role="system", content="You are a helpful assistant."),
+                Message(role="user", content="Tell me a story!")
+            ],
+            stream=True
+        )
+        async for chunk in await client.generate(stream_request):
+            print(chunk)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## API Reference
+
+### Client Initialization
+
+The SDK provides two client classes:
+- `MiraSyncClient`: Synchronous client using `requests`
+- `MiraClient`: Asynchronous client using `httpx`
+
+Both clients support context managers for proper resource cleanup:
+
+```python
+# Synchronous
+with MiraSyncClient(api_token="your-api-token") as client:
+    # Your sync code here
+
+# Asynchronous
+async with MiraClient(api_token="your-api-token") as client:
+    # Your async code here
+```
+
+### Models
+
+- `Message`: Represents a chat message
+  - `role`: String ("system", "user", or "assistant")
+  - `content`: String content of the message
+
+- `AiRequest`: Configuration for model inference
+  - `model`: Model identifier (default: "mira/llama3.1")
+  - `messages`: List of Message objects
+  - `stream`: Boolean to enable streaming responses (default: False)
+  - `model_provider`: Optional ModelProvider configuration
+
+- `ModelProvider`: Custom provider configuration
+  - `base_url`: Provider's base URL
+  - `api_key`: Provider's API key
+
+- `ApiTokenRequest`: Request for creating API tokens
+  - `description`: Optional description for the token
+
+### Available Methods
+
+Both sync and async clients provide the same methods with identical parameters. The only difference is that async methods must be awaited.
+
+#### Model Operations
+```python
+# Sync
+models = client.list_models()
+response = client.generate(AiRequest(messages=[...], stream=False))
+for chunk in client.generate(AiRequest(messages=[...], stream=True)):
+    print(chunk)
+
+# Async
+models = await client.list_models()
+response = await client.generate(AiRequest(messages=[...], stream=False))
+async for chunk in await client.generate(AiRequest(messages=[...], stream=True)):
+    print(chunk)
+```
+
+#### API Token Operations
+```python
+# Sync
+token = client.create_api_token(ApiTokenRequest(description="My Token"))
+tokens = client.list_api_tokens()
+client.delete_api_token("token-to-delete")
+
+# Async
+token = await client.create_api_token(ApiTokenRequest(description="My Token"))
+tokens = await client.list_api_tokens()
+await client.delete_api_token("token-to-delete")
+```
+
+#### Credit Operations
+```python
+# Sync
+credits = client.get_user_credits()
+history = client.get_credits_history()
+
+# Async
+credits = await client.get_user_credits()
+history = await client.get_credits_history()
+```
+
+## License
+
+MIT License

mira_network-0.1.4.dist-info/RECORD

@@ -0,0 +1,8 @@
+mira_network-0.1.4.dist-info/METADATA,sha256=l_M7hizI6V3qfd94wTFRb9tViHhN62_7Ze4QOGy6i_Y,5026
+mira_network-0.1.4.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+mira_network-0.1.4.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+mira_network/__init__.py,sha256=82x6bhP9_ZhHaBkW-O10F4ADipp1crGQzTaxQ878buA,272
+mira_network/client.py,sha256=_Fj4g20CSyzqHnDHhn43TunFLLub_n2Ix3cBAwa7spU,5739
+mira_network/models.py,sha256=aEJiDHEDFIAQMB-C8ZFY5ruRNGJ-U2Cz9vS5nF7GqVg,1805
+mira_network/sync_client.py,sha256=0f_oakroMp-OYC-WRvNRcWnQW9YtUdQRdVxKNeNbMUA,3400
+mira_network-0.1.4.dist-info/RECORD,,

mira_network-0.1.2.dist-info/METADATA

@@ -1,107 +0,0 @@
-Metadata-Version: 2.1
-Name: mira-network
-Version: 0.1.2
-Summary: Python SDK for Mira Network API
-Author-Email: sarim2000 <sarimbleedblue@gmail.com>
-License: MIT
-Requires-Python: ==3.10.*
-Requires-Dist: httpx>=0.28.1
-Requires-Dist: pydantic>=2.10.4
-Requires-Dist: typing-extensions>=4.8.0
-Requires-Dist: requests>=2.32.3
-Description-Content-Type: text/markdown
-
-# Mira Network SDK
-
-A Python SDK for interacting with the Mira Network API. This SDK provides a simple interface to access all Mira API endpoints including model inference, flow management, and credit system.
-
-## Installation
-
-```bash
-pip install mira-network
-```
-
-## Quick Start
-
-```python
-import asyncio
-from mira_sdk import MiraClient, Message, AiRequest
-
-async def main():
-    # Initialize client
-    client = MiraClient(
-        base_url="https://api.mira.example.com",
-        api_token="your-api-token"
-    )
-    
-    # List available models
-    models = await client.list_models()
-    print("Available models:", models)
-    
-    # Generate text
-    request = AiRequest(
-        model="mira/llama3.1",
-        messages=[
-            Message(role="system", content="You are a helpful assistant."),
-            Message(role="user", content="Hello!")
-        ],
-        model_provider=None
-    )
-    
-    response = await client.generate(request)
-    print("Response:", response)
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-
-## Features
-
-- Asynchronous API using `httpx`
-- Full type hints support
-- Pydantic models for request/response validation
-- Support for all Mira API endpoints:
-  - Model inference
-  - Flow management
-  - API token management
-  - Credit system
-
-## API Reference
-
-### Models
-
-- `Message`: Represents a chat message
-- `ModelProvider`: Configuration for custom model providers
-- `AiRequest`: Request for model inference
-- `FlowChatCompletion`: Request for flow-based chat completion
-- `FlowRequest`: Request for creating/updating flows
-- `ApiTokenRequest`: Request for creating API tokens
-- `AddCreditRequest`: Request for adding credits
-
-### Client Methods
-
-#### Model Operations
-- `list_models()`: List available models
-- `generate(request: AiRequest)`: Generate text using specified model
-
-#### Flow Operations
-- `list_flows()`: List all flows
-- `get_flow(flow_id: str)`: Get flow details
-- `create_flow(request: FlowRequest)`: Create new flow
-- `update_flow(flow_id: str, request: FlowRequest)`: Update flow
-- `delete_flow(flow_id: str)`: Delete flow
-- `generate_with_flow(flow_id: str, request: FlowChatCompletion)`: Generate using flow
-
-#### Token Operations
-- `create_api_token(request: ApiTokenRequest)`: Create API token
-- `list_api_tokens()`: List API tokens
-- `delete_api_token(token: str)`: Delete API token
-
-#### Credit Operations
-- `get_user_credits()`: Get credit information
-- `add_credit(request: AddCreditRequest)`: Add credits
-- `get_credits_history()`: Get credit history
-
-## License
-
-MIT License

mira_network-0.1.2.dist-info/RECORD

@@ -1,7 +0,0 @@
-mira_network-0.1.2.dist-info/METADATA,sha256=KrCNwQMJqIY3acFF9c00JXWnCnAm0Z_SArKg4dLO8_k,2915
-mira_network-0.1.2.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-mira_network-0.1.2.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-mira_sdk/__init__.py,sha256=KVFj7e20pprJuOWCG9Ky_w2JqKBu8TFPCilPDKRhkyI,364
-mira_sdk/client.py,sha256=F0E0ATGZXOsozbp91P6MLma5-pgT0rCo0BaEIz-yKDk,5769
-mira_sdk/models.py,sha256=FQfxjK_Cs7Nt0dB1qYHd7rov3VJSVr6rNAqZqOarU48,1749
-mira_network-0.1.2.dist-info/RECORD,,

mira_sdk/client.py

@@ -1,180 +0,0 @@
-from typing import Optional, List, Dict, AsyncGenerator, Union
-import httpx
-from mira_sdk.models import (
-    Message,
-    ModelProvider,
-    AiRequest,
-    FlowChatCompletion,
-    FlowRequest,
-    ApiTokenRequest,
-    AddCreditRequest,
-)
-
-
-class MiraClient:
-    def __init__(self, base_url: str, api_token: Optional[str] = None):
-        """Initialize Mira client.
-
-        Args:
-            base_url: Base URL of the Mira API
-            api_token: Optional API token for authentication
-        """
-        self.base_url = base_url
-        self.api_token = api_token
-        self._client = httpx.AsyncClient()
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self._client.aclose()
-
-    def _get_headers(self) -> Dict[str, str]:
-        headers = {"Content-Type": "application/json"}
-        if self.api_token:
-            headers["Authorization"] = f"Bearer {self.api_token}"
-        return headers
-
-    async def list_models(self) -> List[str]:
-        """List available models."""
-        response = await self._client.get(
-            f"{self.base_url}/v1/models",
-            headers=self._get_headers(),
-        )
-        response.raise_for_status()
-        return response.json()
-
-    async def generate(
-        self, request: AiRequest
-    ) -> Union[str, AsyncGenerator[str, None]]:
-        """Generate text using the specified model."""
-        response = await self._client.post(
-            f"{self.base_url}/v1/chat/completions",
-            headers=self._get_headers(),
-            json=request.model_dump(),
-        )
-
-        response.raise_for_status()
-
-        if request.stream:
-
-            async def stream_response():
-                async for chunk in response.aiter_text():
-                    yield chunk
-
-            return stream_response()
-        else:
-            return response.json()
-
-    async def generate_with_flow(
-        self, flow_id: str, request: FlowChatCompletion
-    ) -> Union[str, AsyncGenerator[str, None]]:
-        """Generate text using a specific flow."""
-        response = await self._client.post(
-            f"{self.base_url}/v1/flows/{flow_id}/chat/completions",
-            headers=self._get_headers(),
-            json=request.model_dump(),
-        )
-        response.raise_for_status()
-        return response.json()
-
-    async def list_flows(self) -> List[Dict]:
-        """List all flows."""
-        response = await self._client.get(
-            f"{self.base_url}/flows",
-            headers=self._get_headers(),
-        )
-        response.raise_for_status()
-        return response.json()
-
-    async def get_flow(self, flow_id: str) -> Dict:
-        """Get details of a specific flow."""
-        response = await self._client.get(
-            f"{self.base_url}/flows/{flow_id}",
-            headers=self._get_headers(),
-        )
-        response.raise_for_status()
-        return response.json()
-
-    async def create_flow(self, request: FlowRequest) -> Dict:
-        """Create a new flow."""
-        response = await self._client.post(
-            f"{self.base_url}/flows",
-            headers=self._get_headers(),
-            json=request.model_dump(),
-        )
-        response.raise_for_status()
-        return response.json()
-
-    async def update_flow(self, flow_id: str, request: FlowRequest) -> Dict:
-        """Update an existing flow."""
-        response = await self._client.put(
-            f"{self.base_url}/flows/{flow_id}",
-            headers=self._get_headers(),
-            json=request.model_dump(),
-        )
-        response.raise_for_status()
-        return response.json()
-
-    async def delete_flow(self, flow_id: str) -> None:
-        """Delete a flow."""
-        response = await self._client.delete(
-            f"{self.base_url}/flows/{flow_id}",
-            headers=self._get_headers(),
-        )
-        response.raise_for_status()
-
-    async def create_api_token(self, request: ApiTokenRequest) -> Dict:
-        """Create a new API token."""
-        response = await self._client.post(
-            f"{self.base_url}/tokens",
-            headers=self._get_headers(),
-            json=request.model_dump(),
-        )
-        response.raise_for_status()
-        return response.json()
-
-    async def list_api_tokens(self) -> List[Dict]:
-        """List all API tokens."""
-        response = await self._client.get(
-            f"{self.base_url}/tokens",
-            headers=self._get_headers(),
-        )
-        response.raise_for_status()
-        return response.json()
-
-    async def delete_api_token(self, token: str) -> None:
-        """Delete an API token."""
-        response = await self._client.delete(
-            f"{self.base_url}/tokens/{token}",
-            headers=self._get_headers(),
-        )
-        response.raise_for_status()
-
-    async def get_user_credits(self) -> Dict:
-        """Get user credits information."""
-        response = await self._client.get(
-            f"{self.base_url}/credits",
-            headers=self._get_headers(),
-        )
-        response.raise_for_status()
-        return response.json()
-
-    async def add_credit(self, request: AddCreditRequest) -> Dict:
-        """Add credits to a user account."""
-        response = await self._client.post(
-            f"{self.base_url}/credits",
-            headers=self._get_headers(),
-            json=request.model_dump(),
-        )
-        response.raise_for_status()
-        return response.json()
-
-    async def get_credits_history(self) -> List[Dict]:
-        """Get user credits history."""
-        response = await self._client.get(
-            f"{self.base_url}/credits/history",
-            headers=self._get_headers(),
-        )
-        response.raise_for_status()
-        return response.json()