mira-network 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

mira_network/__init__.py

@@ -1,5 +1,4 @@
 from .client import MiraClient
-from .sync_client import MiraSyncClient
 from .models import (
     Message,
     ModelProvider,

mira_network/client.py

@@ -1,26 +1,26 @@
-from typing import AsyncIterator, Optional, List, Dict, AsyncGenerator, Union
+from typing import AsyncIterator, Optional, List, Dict, Union, Any
 import httpx
 from .models import (
     AiRequest,
     ApiTokenRequest,
+    Message,
 )
 
 
 class MiraClient:
-
     def __init__(
         self,
+        api_key: Optional[str] = None,
         base_url: str = "https://apis.mira.network",
-        api_token: Optional[str] = None,
     ):
         """Initialize Mira client.
 
         Args:
+            api_key: API key for authentication
             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.api_key = api_key
         self._client = httpx.AsyncClient()
 
     async def __aenter__(self):
@@ -31,91 +31,72 @@ class MiraClient:
 
     def _get_headers(self) -> Dict[str, str]:
         headers = {"Content-Type": "application/json"}
-        if self.api_token:
-            headers["Authorization"] = f"Bearer {self.api_token}"
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
         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(),
+    async def chat_completions_create(
+        self,
+        model: str,
+        messages: list[Message],
+        stream: bool = False,
+        **kwargs: Any,
+    ) -> Union[Dict[str, Any], AsyncIterator[Dict[str, Any]]]:
+        """Create a chat completion.
+
+        Args:
+            model: The model to use for completion
+            messages: A list of messages in the conversation
+            stream: Whether to stream the response
+            **kwargs: Additional parameters to pass to the API
+        """
+        request = AiRequest(
+            model=model,
+            messages=messages,
+            stream=stream,
+            **kwargs,
         )
-        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()
+        if stream:
+            return self._stream_response(response)
+        return response.json()
+
+    async def _stream_response(
+        self, response: httpx.Response
+    ) -> AsyncIterator[Dict[str, Any]]:
+        """Handle streaming response.
+
+        Args:
+            response: The HTTP response object
+        """
+        async for line in response.aiter_lines():
+            if line.strip():
+                yield self._format_stream_response(line)
+
+    def _format_stream_response(self, line: str) -> Dict[str, Any]:
+        """Format streaming response to match OpenAI's format.
+
+        Args:
+            line: The response line
+        """
+        # Add formatting logic here if needed
+        return {"choices": [{"delta": {"content": line}}]}
+
+    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 create_api_token(self, request: ApiTokenRequest) -> Dict:
         """Create a new API token."""
@@ -153,16 +134,6 @@ class MiraClient:
         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(

mira_network/models.py

@@ -1,4 +1,4 @@
-from typing import Optional, List, Dict
+from typing import Optional, List
 from pydantic import BaseModel, Field, field_validator
 
 

mira_network/sync_client.py

@@ -10,7 +10,7 @@ class MiraSyncClient:
     def __init__(
         self,
         base_url: str = "https://apis.mira.network",
-        api_token: Optional[str] = None,
+        api_key: Optional[str] = None,
     ):
         """Initialize Mira synchronous client.
 
@@ -19,7 +19,7 @@ class MiraSyncClient:
             api_token: Optional API token for authentication
         """
         self.base_url = base_url
-        self.api_token = api_token
+        self.api_key = api_key
         self._session = requests.Session()
 
     def __enter__(self):
@@ -30,8 +30,8 @@ class MiraSyncClient:
 
     def _get_headers(self) -> Dict[str, str]:
         headers = {"Content-Type": "application/json"}
-        if self.api_token:
-            headers["Authorization"] = f"Bearer {self.api_token}"
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
         return headers
 
     def list_models(self) -> List[str]:

mira_network-0.1.7.dist-info/METADATA

@@ -0,0 +1,362 @@
+Metadata-Version: 2.1
+Name: mira-network
+Version: 0.1.7
+Summary: Python SDK for Mira Network API
+Author-Email: mira-network <sdk@mira.network>
+License: MIT
+Requires-Python: <3.14,>=3.9
+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
+Requires-Dist: pytest>=8.3.4
+Requires-Dist: pytest-asyncio>=0.25.0
+Requires-Dist: ruff>=0.9.3
+Requires-Dist: black>=25.1.0
+Description-Content-Type: text/markdown
+
+<div align="center">
+  <img src="https://mira.network/_next/static/media/nav_logo.dfc4db53.svg" alt="Mira Network SDK" width="100"/>
+  <h1>Mira Network Python SDK</h1>
+  <p><strong>Your Universal Gateway to AI Language Models</strong></p>
+</div>
+
+<p align="center">
+  <!-- Version and Download stats -->
+  <a href="https://pypi.org/project/mira-network/"><img src="https://img.shields.io/pypi/v/mira-network" alt="PyPI Version"></a>
+  <a href="https://pypi.org/project/mira-network/"><img src="https://img.shields.io/pypi/dm/mira-network" alt="Downloads"></a>
+  
+  <!-- Package metadata -->
+  <a href="https://pypi.org/project/mira-network/"><img src="https://img.shields.io/pypi/format/mira-network" alt="Format"></a>
+  <a href="https://pypi.org/project/mira-network/"><img src="https://img.shields.io/pypi/implementation/mira-network" alt="Implementation"></a>
+  
+  <!-- License -->
+  <a href="https://pypi.org/project/mira-network/"><img src="https://img.shields.io/pypi/l/mira-network" alt="License"></a>
+  
+  <!-- Build Status -->
+  <a href="https://github.com/Aroha-Labs/mira-network/actions/workflows/ci-sdk.yml">
+    <img src="https://github.com/Aroha-Labs/mira-network/actions/workflows/ci-sdk.yml/badge.svg" alt="Build Status">
+  </a>
+</p>
+
+<p align="center">
+  <b>Mira Client enables seamless integration with multiple language models while providing advanced routing, load balancing, and flow management capabilities.</b>
+</p>
+
+---
+
+## 🌟 What is Mira Network?
+
+Mira Network is your unified interface to the world of AI language models. It provides:
+
+- 🔄 **Smart Model Routing**: Route requests across different models
+- ⚖️ **Load Balancing**: Distribute workload across nodes
+- 🌊 **Flow Management**: Handle request patterns efficiently
+- 🔌 **Universal Integration**: Single API for multiple models
+- 📊 **Usage Tracking**: Monitor your model usage
+
+## Why Mira Network SDK?
+
+| Feature                | Mira SDK                   | Traditional Approach    |
+| ---------------------- | -------------------------- | ----------------------- |
+| 🔄 Multi-model Support | Single unified API         | Separate APIs per model |
+| ⚖️ Load Balancing      | Built-in                   | Custom implementation   |
+| 🌊 Flow Control        | Automatic handling         | Manual implementation   |
+| 📊 Usage Tracking      | Integrated                 | Custom tracking needed  |
+| 🛡️ Error Handling      | Standardized across models | Model-specific handling |
+
+## 🎯 Perfect For
+
+- 🤖 AI Applications
+- 📝 Text Generation
+- 🔍 Search Enhancement
+- 🎮 Interactive Systems
+
+## 🏃 Quick Start
+
+```bash
+pip install mira-network
+```
+
+```python
+from mira_network import MiraClient
+
+async def get_ai_response(prompt):
+    async with MiraClient() as client:
+        return await client.chat_completions_create(
+            model="your-chosen-model",
+            messages=[{"role": "user", "content": prompt}]
+        )
+```
+
+## 🏗️ Architecture
+
+```mermaid
+graph LR
+    A[Your App] --> B[Mira SDK]
+    B --> C[Load Balancer]
+    C --> D[Mira Node 1]
+    C --> E[Mira Node 2]
+    C --> F[Mira Node N]
+```
+
+## ✨ Key Features
+
+- 🔌 Simple, intuitive API
+- 🔄 Async-first design
+- 🌊 Streaming support
+- 🔐 Error handling
+- 🛠️ Customizable nodes
+- 📊 Usage tracking
+
+## 📑 Table of Contents
+
+- [Installation](#installation)
+- [Quick Start](#-quick-start)
+- [Basic Usage](#-basic-usage)
+- [Advanced Usage](#-advanced-usage)
+- [API Reference](#-reference)
+- [Support](#-support)
+- [Contributing](#-contributing)
+- [License](#-license)
+
+## 🔧 Installation
+
+Install the SDK using pip:
+
+```bash
+pip install mira-network
+```
+
+## 🚀 Quick Start
+
+Experience the power of Mira Network in just a few lines of code:
+
+```python
+from mira_network import MiraClient
+
+async def main():
+    # Initialize with your API key
+    client = MiraClient(api_key="your-api-key")
+
+    # Get a response from AI
+    response = await client.chat_completions_create(
+        model="your-chosen-model",
+        messages=[
+            {"role": "user", "content": "What is the capital of France?"}
+        ]
+    )
+
+    # Print the AI's response
+    print(response["choices"][0]["message"]["content"])
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())
+```
+
+## 📝 Basic Usage
+
+### Having a Conversation
+
+Engage in natural conversations with AI models. The SDK handles the complexities of managing conversation context and model interactions:
+
+```python
+response = await client.chat_completions_create(
+    model="your-chosen-model",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant"},
+        {"role": "user", "content": "Hi! Can you help me?"},
+    ]
+)
+```
+
+### Checking Available Models
+
+Explore the diverse range of available AI models:
+
+```python
+models = await client.list_models()
+print(models)
+```
+
+### Checking Your Credits
+
+Monitor your usage and available credits:
+
+```python
+credits = await client.get_user_credits()
+print(credits)
+```
+
+## 🔧 Advanced Usage
+
+### Streaming Responses
+
+Perfect for real-time applications and interactive experiences:
+
+```python
+stream = await client.chat_completions_create(
+    model="your-chosen-model",
+    messages=[
+        {"role": "user", "content": "Write a story"}
+    ],
+    stream=True
+)
+
+async for chunk in stream:
+    print(chunk["choices"][0]["delta"]["content"], end="")
+```
+
+### Custom Mira Nodes
+
+Integrate your preferred Mira nodes seamlessly:
+
+```python
+response = await client.chat_completions_create(
+    model="your-model",
+    messages=[{"role": "user", "content": "Hello"}],
+    mira_node={
+        "base_url": "https://custom-node.com",
+        "api_key": "node-api-key"
+    }
+)
+```
+
+### API Token Management
+
+Secure and flexible token management for your applications:
+
+```python
+# Create new token
+new_token = await client.create_api_token(
+    {"description": "Production API Key"}
+)
+
+# List tokens
+tokens = await client.list_api_tokens()
+
+# Delete token
+await client.delete_api_token("token-id")
+```
+
+### Using as Context Manager
+
+Efficient resource management with context managers:
+
+```python
+async with MiraClient(api_key="your-api-key") as client:
+    response = await client.chat_completions_create(...)
+```
+
+## 📚 Reference
+
+### Message Structure
+
+Understanding the core message components:
+
+```python
+Message:
+    role: str       # "system", "user", or "assistant"
+    content: str    # The message content
+```
+
+### Error Handling
+
+Robust error handling for production applications:
+
+#### Validation Errors
+
+```python
+try:
+    response = await client.chat_completions_create(
+        model="your-chosen-model",
+        messages=[
+            {"role": "invalid", "content": "Hello"}  # Invalid role
+        ]
+    )
+except ValueError as e:
+    print(f"Validation error: {e}")
+```
+
+#### Network Errors
+
+```python
+try:
+    response = await client.chat_completions_create(...)
+except httpx.HTTPError as e:
+    print(f"HTTP error: {e}")
+```
+
+### Environment Configuration
+
+Flexible configuration options for different environments:
+
+```python
+import os
+from mira_network import MiraClient
+
+client = MiraClient(
+    api_key=os.getenv("MIRA_API_KEY"),
+    base_url=os.getenv("MIRA_API_URL", "https://apis.mira.network")
+)
+```
+
+## 💡 Real-world Examples
+
+### AI-powered Customer Service
+
+```python
+async def handle_customer_query(query: str) -> str:
+    async with MiraClient() as client:
+        response = await client.chat_completions_create(
+            model="your-chosen-model",
+            messages=[
+                {"role": "system", "content": "You are a helpful customer service agent."},
+                {"role": "user", "content": query}
+            ],
+            temperature=0.7,
+            max_tokens=150
+        )
+        return response.choices[0].message.content
+```
+
+### Content Generation Pipeline
+
+```python
+async def generate_blog_post(topic: str) -> dict:
+    async with MiraClient() as client:
+        # Generate outline
+        outline = await client.chat_completions_create(...)
+
+        # Generate content
+        content = await client.chat_completions_create(...)
+
+        # Generate meta description
+        meta = await client.chat_completions_create(...)
+
+        return {"outline": outline, "content": content, "meta": meta}
+```
+
+## 🤝 Support
+
+For feature requests and bug reports, please visit our [Console Feedback](https://console-feedback.arohalabs.tech/).
+
+## 👥 Contributing
+
+We welcome contributions! Here's how you can help:
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+---
+
+<p align="center">Built with ❤️ by the Mira Network team</p>

mira_network-0.1.7.dist-info/RECORD

@@ -0,0 +1,9 @@
+mira_network-0.1.7.dist-info/METADATA,sha256=26Wnxl4rxw73IIN5XtBJZ4LuVkr5js5OR333QYXDtfE,9478
+mira_network-0.1.7.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+mira_network-0.1.7.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+mira_network-0.1.7.dist-info/licenses/LICENSE,sha256=bOPoXuA3yH-uo70eTxPrRY4aiy8NkZDVkI8ZVagZIfc,1069
+mira_network/__init__.py,sha256=h4vgSUv520lY8Ij_k5GclS9elYe1gXKfDnq70Zu-7Og,232
+mira_network/client.py,sha256=ykbdbjp5rS0ZSbN7w_SEd57_Hvo1yjExX3ojGjaoSx4,4390
+mira_network/models.py,sha256=VkJjAmVIx3L5U3G0WVcdcEAXnNgud5gjRVfGGsYVtvQ,1799
+mira_network/sync_client.py,sha256=Q5gzIx92mfFsS90hogtzvjNC51tL6zC4HZzQoK0oJ-Q,3389
+mira_network-0.1.7.dist-info/RECORD,,

mira_network-0.1.7.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mira Network
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mira_network-0.1.5.dist-info/METADATA

@@ -1,186 +0,0 @@
-Metadata-Version: 2.1
-Name: mira-network
-Version: 0.1.5
-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:  # base_url defaults to https://apis.mira.network/
-    # 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:  # base_url defaults to https://apis.mira.network/
-        # Example 1: Non-streaming response
-        request = AiRequest(
-            messages=[
-                Message(role="system", content="You are a helpful assistant."),
-                Message(role="user", content="Hello!")
-            ],
-            model="gpt-4o",
-            model_provider=None,
-            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",
-    base_url="https://apis.mira.network/"  # Optional, this is the default
-) as client:
-    # Your sync code here
-
-# Asynchronous
-async with MiraClient(
-    api_token="your-api-token",
-    base_url="https://apis.mira.network/"  # Optional, this is the default
-) 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.5.dist-info/RECORD

@@ -1,8 +0,0 @@
-mira_network-0.1.5.dist-info/METADATA,sha256=Q9jRYiP-Oo6ecT8iBgCIxi4pT-4nbHwuEP-8vgZ2OEc,5353
-mira_network-0.1.5.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-mira_network-0.1.5.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-mira_network/__init__.py,sha256=82x6bhP9_ZhHaBkW-O10F4ADipp1crGQzTaxQ878buA,272
-mira_network/client.py,sha256=HEqj1G1VfDZxZ3Kh2YPNBeUMlB5Pb56HBSvh80Wde2c,5738
-mira_network/models.py,sha256=aEJiDHEDFIAQMB-C8ZFY5ruRNGJ-U2Cz9vS5nF7GqVg,1805
-mira_network/sync_client.py,sha256=vAiQG0SDHO9aROklnPqr0m-AsPIyL8wNfA0L7h5EhPg,3399
-mira_network-0.1.5.dist-info/RECORD,,