askai-python 0.4.0__tar.gz → 0.4.1__tar.gz

{askai_python-0.4.0 → askai_python-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: askai-python
-Version: 0.4.0
+Version: 0.4.1
 Summary: AI Made Stupid Simple. Unified API for OpenAI, Groq, Google, Anthropic, and more.
 Author-email: Hossein Ghorbani <hosseingh1068@gmail.com>
 License: MIT
@@ -143,6 +143,54 @@ response = ai.ask(
 )
 ```
 
+## 🎨 Media Generation (Image & Audio)
+
+Generate images or speech with compatible providers:
+
+```python
+from ask_ai import OpenAI
+
+ai = OpenAI()
+
+# Generate an Image (DALL-E)
+img_response = ai.ask("A majestic lion in a neon city", output_type="image")
+img_response.save("lion.png")
+
+# Generate Speech (TTS)
+audio_response = ai.ask("Hello, this is a voice.", output_type="audio")
+audio_response.save("welcome.mp3")
+```
+
+## 🔗 Provider Fallback
+
+Never experience downtime by supplying fallback providers:
+
+```python
+from ask_ai import OpenAI, Groq
+
+ai = OpenAI()
+response = ai.ask("Explain quantum physics", providers=[ai, Groq])
+print(response.text)
+```
+
+## 📋 Structured Output (Pydantic Support)
+
+Force LLMs to strictly respond matching a Pydantic schema:
+
+```python
+from pydantic import BaseModel
+from ask_ai import OpenAI
+
+class User(BaseModel):
+    name: str
+    age: int
+
+ai = OpenAI()
+response = ai.ask("Extract name: Alice is 30.", response_model=User)
+user = response.pydantic
+print(user.name)  # "Alice"
+```
+
 ## 🔌 Supported Providers
 
 | Provider | Class | Capabilities |
@@ -158,11 +206,19 @@ response = ai.ask(
 
 ## 🗺️ Roadmap
 
-- [x] Baseline multiple providers
-- [x] Automated Retry & Timeout controls
-- [ ] Async API (`await ask_async`)
-- [ ] Provider Fallback (`fallback=[Groq()]`)
-- [ ] Structured Outputs (Pydantic Support)
+### 🚀 Roadmap 2.0 (Active)
+- [x] Provider Fallback chaining & Pydantic Structured Output support
+- [ ] Multi-Modal Vision input (image to text) for all key providers
+- [ ] Native support for tools/function calling execution
+- [ ] Memory buffer / session-based conversation management
+
+### 🏁 Roadmap 1.0 (Completed)
+- ~~[x] Baseline multiple providers~~
+- ~~[x] Automated Retry & Timeout controls~~
+- ~~[x] Async API (`await ask_async`)~~
+- ~~[x] Streaming Support (`ask_stream` / `ask_stream_async`)~~
+- ~~[x] Provider Fallback (`fallback=[Groq()]`)~~
+- ~~[x] Structured Outputs (Pydantic Support)~~
 
 ---
 

{askai_python-0.4.0 → askai_python-0.4.1}/README.md

@@ -24,7 +24,7 @@
 
 [![PyPI version](https://img.shields.io/pypi/v/askai-python.svg)](https://pypi.org/project/askai-python/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
 
 
 
@@ -144,15 +144,101 @@ asyncio.run(main())
 
 ---
 
+### 🌊 Streaming Support (Sync & Async)
+
+Stream responses token-by-token easily:
+
+```python
+from ask_ai import OpenAI
+
+ai = OpenAI()
+
+# Sync Streaming
+for chunk in ai.ask_stream("Write a short story about a blue dragon"):
+    print(chunk, end="", flush=True)
+
+# Async Streaming
+async def stream_example():
+    async for chunk in await ai.ask_stream_async("Write a short story"):
+        print(chunk, end="", flush=True)
+```
+
+---
+
+### 🎨 Media Generation (Image & Audio)
+
+Generate images or speech with compatible providers:
+
+```python
+from ask_ai import OpenAI
+
+ai = OpenAI()
+
+# Generate an Image (DALL-E)
+img_response = ai.ask("A majestic lion in a neon city", output_type="image")
+img_response.save("lion.png")
+
+# Generate Speech (TTS)
+audio_response = ai.ask("Hello, this is a generated voice.", output_type="audio")
+audio_response.save("welcome.mp3")
+```
+
+---
+
+### 🔗 Provider Fallback
+
+Never experience downtime by supplying alternative fallback providers:
+
+```python
+from ask_ai import OpenAI, Groq
+
+ai = OpenAI()
+
+# If OpenAI fails or rate-limits, it automatically switches to Groq
+response = ai.ask("Explain quantum physics", providers=[ai, Groq])
+print(response.text)
+```
+
+---
+
+### 📋 Structured Output (Pydantic Support)
+
+Force LLMs to strictly respond matching a Pydantic schema:
+
+```python
+from pydantic import BaseModel
+from ask_ai import OpenAI
+
+class User(BaseModel):
+    name: str
+    age: int
+
+ai = OpenAI()
+response = ai.ask("Extract name: Alice is 30 years old.", response_model=User)
+
+user = response.pydantic
+print(user.name)  # "Alice"
+print(user.age)   # 30
+```
+
+---
+
 ## 🗺️ Roadmap
 
-- [x] OpenAI, Groq, Gemini, Anthropic, Azure, OpenRouter support
-- [x] Text to Image (DALL-E) and Text to Audio
-- [x] Automated Retry & Timeout controls
-- [x] Async Support (`await ask_async`)
-- [ ] Provider Fallback (`ask(..., providers=[OpenAI, Groq])`)
-- [ ] Streaming Support (`ask_stream`)
-- [ ] Structured Output (Pydantic Support)
+### 🚀 Roadmap 2.0 (Active)
+- [x] Provider Fallback chaining & Pydantic Structured Output support
+- [ ] Multi-Modal Vision input (image to text) for all key providers
+- [ ] Native support for tools/function calling execution
+- [ ] Memory buffer / session-based conversation management
+
+### 🏁 Roadmap 1.0 (Completed)
+- ~~[x] OpenAI, Groq, Gemini, Anthropic, Azure, OpenRouter support~~
+- ~~[x] Text to Image (DALL-E) and Text to Audio~~
+- ~~[x] Automated Retry & Timeout controls~~
+- ~~[x] Async Support (`await ask_async`)~~
+- ~~[x] Streaming Support (`ask_stream` / `ask_stream_async`)~~
+- ~~[x] Provider Fallback (`ask(..., providers=[OpenAI, Groq])`)~~
+- ~~[x] Structured Output (Pydantic Support)~~
 
 ---
 

{askai_python-0.4.0 → askai_python-0.4.1}/ask_ai/__init__.py

@@ -2,7 +2,7 @@
 ask-ai: A minimal Python SDK to switch between LLM providers in one line.
 """
 
-__version__ = "0.4.0"
+__version__ = "0.4.1"
 
 from .providers import (
     OpenAI,

{askai_python-0.4.0 → askai_python-0.4.1}/ask_ai/base.py

@@ -15,9 +15,10 @@ class Response:
     """
     Unified response object for all ask-ai requests.
     """
-    def __init__(self, text: str = "", media: Union[ImageObject, AudioObject, None] = None, **kwargs):
+    def __init__(self, text: str = "", media: Union[ImageObject, AudioObject, None] = None, response_model: Any = None, **kwargs):
         self._raw_text = text
         self.media = media
+        self.response_model = response_model
         self._kwargs = kwargs
 
     @property
@@ -40,6 +41,25 @@ class Response:
         from .utils import parse_json
         return parse_json(self._raw_text)
 
+    @property
+    def pydantic(self) -> Any:
+        """Returns parsed Pydantic model instance if response_model was provided."""
+        if not self.response_model:
+            raise ValueError("No response_model was specified for this request.")
+        return self.to_model(self.response_model)
+
+    def to_model(self, model_class: Any) -> Any:
+        """Parse the response text into a specified Pydantic model."""
+        text_content = self.text
+        if hasattr(model_class, "model_validate_json"):
+            return model_class.model_validate_json(text_content)
+        elif hasattr(model_class, "parse_raw"):
+            return model_class.parse_raw(text_content)
+        else:
+            import json
+            data = json.loads(text_content)
+            return model_class(**data)
+
     def __str__(self) -> str:
         return self.text
 
@@ -97,19 +117,68 @@ class BaseProvider:
         The main entry point. Sync version.
         Detects intent, manages config, and returns a unified Response.
         """
+        providers = kwargs.pop("providers", None) or kwargs.pop("fallback", None)
+        if providers:
+            if not isinstance(providers, (list, tuple)):
+                providers = [providers]
+            errors = []
+            for p in providers:
+                if isinstance(p, type):
+                    try:
+                        p_inst = p()
+                    except Exception as e:
+                        errors.append(f"{p.__name__} init failed: {e}")
+                        continue
+                else:
+                    p_inst = p
+                try:
+                    return p_inst.ask(query, **kwargs)
+                except Exception as e:
+                    errors.append(f"{p_inst.__class__.__name__}: {e}")
+                    logger.warning("Provider fallback failed for %s: %s", p_inst.__class__.__name__, e)
+            from .exceptions import ProviderError
+            raise ProviderError(f"All fallback providers failed: {errors}")
+
         final_config = self._build_final_config(kwargs)
         messages = self._prepare_messages(query, final_config)
         output_type = kwargs.get('output_type')
         retry = int(kwargs.get('retry', final_config.extra.get('retry', 0)) or 0)
+        response_model = kwargs.get('response_model')
 
-        return self._execute_with_retry(
+        response = self._execute_with_retry(
             self._send_request, messages, final_config, output_type, retry
         )
+        if response_model:
+            response.response_model = response_model
+        return response
 
     def ask_stream(self, query: str, **kwargs) -> Iterator[str]:
         """
         Streaming text generation. Yields text chunks.
         """
+        providers = kwargs.pop("providers", None) or kwargs.pop("fallback", None)
+        if providers:
+            if not isinstance(providers, (list, tuple)):
+                providers = [providers]
+            errors = []
+            for p in providers:
+                if isinstance(p, type):
+                    try:
+                        p_inst = p()
+                    except Exception as e:
+                        errors.append(f"{p.__name__} init failed: {e}")
+                        continue
+                else:
+                    p_inst = p
+                try:
+                    yield from p_inst.ask_stream(query, **kwargs)
+                    return
+                except Exception as e:
+                    errors.append(f"{p_inst.__class__.__name__}: {e}")
+                    logger.warning("Provider fallback failed for %s: %s", p_inst.__class__.__name__, e)
+            from .exceptions import ProviderError
+            raise ProviderError(f"All fallback providers failed: {errors}")
+
         final_config = self._build_final_config(kwargs)
         messages = self._prepare_messages(query, final_config)
         yield from self._send_request_stream(messages, final_config)
@@ -121,19 +190,69 @@ class BaseProvider:
         Native async version of ask().
         Uses provider's async client directly — no thread pool wrapping.
         """
+        providers = kwargs.pop("providers", None) or kwargs.pop("fallback", None)
+        if providers:
+            if not isinstance(providers, (list, tuple)):
+                providers = [providers]
+            errors = []
+            for p in providers:
+                if isinstance(p, type):
+                    try:
+                        p_inst = p()
+                    except Exception as e:
+                        errors.append(f"{p.__name__} init failed: {e}")
+                        continue
+                else:
+                    p_inst = p
+                try:
+                    return await p_inst.ask_async(query, **kwargs)
+                except Exception as e:
+                    errors.append(f"{p_inst.__class__.__name__}: {e}")
+                    logger.warning("Provider fallback failed for %s: %s", p_inst.__class__.__name__, e)
+            from .exceptions import ProviderError
+            raise ProviderError(f"All fallback providers failed: {errors}")
+
         final_config = self._build_final_config(kwargs)
         messages = self._prepare_messages(query, final_config)
         output_type = kwargs.get('output_type')
         retry = int(kwargs.get('retry', final_config.extra.get('retry', 0)) or 0)
+        response_model = kwargs.get('response_model')
 
-        return await self._execute_with_retry_async(
+        response = await self._execute_with_retry_async(
             self._send_request_async, messages, final_config, output_type, retry
         )
+        if response_model:
+            response.response_model = response_model
+        return response
 
     async def ask_stream_async(self, query: str, **kwargs) -> AsyncIterator[str]:
         """
         Async streaming text generation. Yields text chunks.
         """
+        providers = kwargs.pop("providers", None) or kwargs.pop("fallback", None)
+        if providers:
+            if not isinstance(providers, (list, tuple)):
+                providers = [providers]
+            errors = []
+            for p in providers:
+                if isinstance(p, type):
+                    try:
+                        p_inst = p()
+                    except Exception as e:
+                        errors.append(f"{p.__name__} init failed: {e}")
+                        continue
+                else:
+                    p_inst = p
+                try:
+                    async for chunk in await p_inst.ask_stream_async(query, **kwargs):
+                        yield chunk
+                    return
+                except Exception as e:
+                    errors.append(f"{p_inst.__class__.__name__}: {e}")
+                    logger.warning("Provider fallback failed for %s: %s", p_inst.__class__.__name__, e)
+            from .exceptions import ProviderError
+            raise ProviderError(f"All fallback providers failed: {errors}")
+
         final_config = self._build_final_config(kwargs)
         messages = self._prepare_messages(query, final_config)
         async for chunk in self._send_request_stream_async(messages, final_config):
@@ -158,8 +277,31 @@ class BaseProvider:
 
         system_msg = config.system_message or self.persona or ""
 
-        # Smart capability: if json=True, enforce JSON system prompt
-        if config.extra.get('json'):
+        # Smart capability: if json=True or response_model is specified
+        response_model = config.extra.get('response_model')
+        if response_model:
+            if hasattr(response_model, "model_json_schema"):
+                schema = response_model.model_json_schema()
+            elif hasattr(response_model, "schema"):
+                schema = response_model.schema()
+            else:
+                schema = None
+
+            if schema:
+                import json
+                schema_str = json.dumps(schema)
+                json_instruction = (
+                    f"You must respond with valid JSON matching the following JSON schema:\n"
+                    f"{schema_str}\n"
+                    f"Do not include any markdown markup, explanation, or HTML tags."
+                )
+            else:
+                json_instruction = "You must respond with valid JSON only."
+
+            system_msg = f"{system_msg}\n{json_instruction}".strip()
+            config.extra['json'] = True
+
+        elif config.extra.get('json'):
             json_instruction = "You must respond with valid JSON only, without any markdown formatting or tags."
             system_msg = f"{system_msg}\n{json_instruction}".strip()
 

askai_python-0.4.1/ask_ai/providers/openrouter_provider.py

@@ -0,0 +1,123 @@
+import os
+from typing import List, Dict, Any
+
+try:
+    import openai
+except ImportError:
+    openai = None
+
+from ..config import AdvancedConfig
+from ..exceptions import APIKeyError, ProviderError
+from .openai_provider import OpenAIProvider
+
+
+class OpenRouterProvider(OpenAIProvider):
+    """OpenRouter provider — routes to multiple models via OpenAI-compatible API."""
+
+    def __init__(self, api_key: str = None, model: str = None, **kwargs):
+        if openai is None:
+            raise ProviderError("OpenAI client library not installed. Run: pip install openai")
+
+        self.api_key = api_key or os.environ.get("OPENROUTER_API_KEY")
+        if not self.api_key:
+            raise APIKeyError("OpenRouter API Key is missing. Set OPENROUTER_API_KEY env var or pass api_key=")
+
+        # Sync client with OpenRouter base URL
+        self.client = openai.OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=self.api_key,
+        )
+        self._async_client = None
+
+        self.model = model or "openai/gpt-4o"
+        self.persona = None
+        self.config = AdvancedConfig(**kwargs)
+
+    @property
+    def async_client(self):
+        """Lazy-load async client for OpenRouter."""
+        if self._async_client is None:
+            self._async_client = openai.AsyncOpenAI(
+                base_url="https://openrouter.ai/api/v1",
+                api_key=self.api_key,
+            )
+        return self._async_client
+
+    def _get_api_key_env_var(self):
+        return "OPENROUTER_API_KEY"
+
+    def _get_default_model(self):
+        return "openai/gpt-4o"
+
+    def _get_media_tools(self) -> List[Dict[str, Any]]:
+        # OpenRouter does not support media endpoints
+        return []
+
+    def _generate_image(self, messages, config):
+        prompt = messages[-1]["content"]
+        try:
+            import httpx
+        except ImportError:
+            raise ProviderError("httpx client library is required for OpenRouter Image Generation. Run: pip install httpx")
+        
+        from ..media import ImageObject
+        from .openai_provider import _download_bytes
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        payload = {
+            "model": self.model,
+            "prompt": prompt
+        }
+        try:
+            response = httpx.post("https://openrouter.ai/api/v1/images", json=payload, headers=headers, timeout=60.0)
+            response.raise_for_status()
+            data = response.json()
+            image_url = data["data"][0]["url"]
+            img_data = _download_bytes(image_url)
+            return Response(
+                text=f"Generated image via OpenRouter ({self.model}) for: {prompt}",
+                media=ImageObject(img_data)
+            )
+        except Exception as e:
+            raise ProviderError(f"OpenRouter Image Generation Error: {e}") from e
+
+    async def _generate_image_async(self, messages, config):
+        prompt = messages[-1]["content"]
+        try:
+            import httpx
+        except ImportError:
+            raise ProviderError("httpx client library is required for OpenRouter Image Generation. Run: pip install httpx")
+
+        from ..media import ImageObject
+        from .openai_provider import _download_bytes_async
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        payload = {
+            "model": self.model,
+            "prompt": prompt
+        }
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post("https://openrouter.ai/api/v1/images", json=payload, headers=headers, timeout=60.0)
+                response.raise_for_status()
+                data = response.json()
+            image_url = data["data"][0]["url"]
+            img_data = await _download_bytes_async(image_url)
+            return Response(
+                text=f"Generated image via OpenRouter ({self.model}) for: {prompt}",
+                media=ImageObject(img_data)
+            )
+        except Exception as e:
+            raise ProviderError(f"OpenRouter Image Generation Error: {e}") from e
+
+    def _generate_audio(self, messages, config):
+        raise ProviderError("OpenRouter does not support Audio Generation via this library.")
+
+    async def _generate_audio_async(self, messages, config):
+        raise ProviderError("OpenRouter does not support Audio Generation via this library.")

{askai_python-0.4.0 → askai_python-0.4.1}/askai_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: askai-python
-Version: 0.4.0
+Version: 0.4.1
 Summary: AI Made Stupid Simple. Unified API for OpenAI, Groq, Google, Anthropic, and more.
 Author-email: Hossein Ghorbani <hosseingh1068@gmail.com>
 License: MIT
@@ -143,6 +143,54 @@ response = ai.ask(
 )
 ```
 
+## 🎨 Media Generation (Image & Audio)
+
+Generate images or speech with compatible providers:
+
+```python
+from ask_ai import OpenAI
+
+ai = OpenAI()
+
+# Generate an Image (DALL-E)
+img_response = ai.ask("A majestic lion in a neon city", output_type="image")
+img_response.save("lion.png")
+
+# Generate Speech (TTS)
+audio_response = ai.ask("Hello, this is a voice.", output_type="audio")
+audio_response.save("welcome.mp3")
+```
+
+## 🔗 Provider Fallback
+
+Never experience downtime by supplying fallback providers:
+
+```python
+from ask_ai import OpenAI, Groq
+
+ai = OpenAI()
+response = ai.ask("Explain quantum physics", providers=[ai, Groq])
+print(response.text)
+```
+
+## 📋 Structured Output (Pydantic Support)
+
+Force LLMs to strictly respond matching a Pydantic schema:
+
+```python
+from pydantic import BaseModel
+from ask_ai import OpenAI
+
+class User(BaseModel):
+    name: str
+    age: int
+
+ai = OpenAI()
+response = ai.ask("Extract name: Alice is 30.", response_model=User)
+user = response.pydantic
+print(user.name)  # "Alice"
+```
+
 ## 🔌 Supported Providers
 
 | Provider | Class | Capabilities |
@@ -158,11 +206,19 @@ response = ai.ask(
 
 ## 🗺️ Roadmap
 
-- [x] Baseline multiple providers
-- [x] Automated Retry & Timeout controls
-- [ ] Async API (`await ask_async`)
-- [ ] Provider Fallback (`fallback=[Groq()]`)
-- [ ] Structured Outputs (Pydantic Support)
+### 🚀 Roadmap 2.0 (Active)
+- [x] Provider Fallback chaining & Pydantic Structured Output support
+- [ ] Multi-Modal Vision input (image to text) for all key providers
+- [ ] Native support for tools/function calling execution
+- [ ] Memory buffer / session-based conversation management
+
+### 🏁 Roadmap 1.0 (Completed)
+- ~~[x] Baseline multiple providers~~
+- ~~[x] Automated Retry & Timeout controls~~
+- ~~[x] Async API (`await ask_async`)~~
+- ~~[x] Streaming Support (`ask_stream` / `ask_stream_async`)~~
+- ~~[x] Provider Fallback (`fallback=[Groq()]`)~~
+- ~~[x] Structured Outputs (Pydantic Support)~~
 
 ---
 

{askai_python-0.4.0 → askai_python-0.4.1}/docs/PYPI_README.md

@@ -96,6 +96,54 @@ response = ai.ask(
 )
 ```
 
+## 🎨 Media Generation (Image & Audio)
+
+Generate images or speech with compatible providers:
+
+```python
+from ask_ai import OpenAI
+
+ai = OpenAI()
+
+# Generate an Image (DALL-E)
+img_response = ai.ask("A majestic lion in a neon city", output_type="image")
+img_response.save("lion.png")
+
+# Generate Speech (TTS)
+audio_response = ai.ask("Hello, this is a voice.", output_type="audio")
+audio_response.save("welcome.mp3")
+```
+
+## 🔗 Provider Fallback
+
+Never experience downtime by supplying fallback providers:
+
+```python
+from ask_ai import OpenAI, Groq
+
+ai = OpenAI()
+response = ai.ask("Explain quantum physics", providers=[ai, Groq])
+print(response.text)
+```
+
+## 📋 Structured Output (Pydantic Support)
+
+Force LLMs to strictly respond matching a Pydantic schema:
+
+```python
+from pydantic import BaseModel
+from ask_ai import OpenAI
+
+class User(BaseModel):
+    name: str
+    age: int
+
+ai = OpenAI()
+response = ai.ask("Extract name: Alice is 30.", response_model=User)
+user = response.pydantic
+print(user.name)  # "Alice"
+```
+
 ## 🔌 Supported Providers
 
 | Provider | Class | Capabilities |
@@ -111,11 +159,19 @@ response = ai.ask(
 
 ## 🗺️ Roadmap
 
-- [x] Baseline multiple providers
-- [x] Automated Retry & Timeout controls
-- [ ] Async API (`await ask_async`)
-- [ ] Provider Fallback (`fallback=[Groq()]`)
-- [ ] Structured Outputs (Pydantic Support)
+### 🚀 Roadmap 2.0 (Active)
+- [x] Provider Fallback chaining & Pydantic Structured Output support
+- [ ] Multi-Modal Vision input (image to text) for all key providers
+- [ ] Native support for tools/function calling execution
+- [ ] Memory buffer / session-based conversation management
+
+### 🏁 Roadmap 1.0 (Completed)
+- ~~[x] Baseline multiple providers~~
+- ~~[x] Automated Retry & Timeout controls~~
+- ~~[x] Async API (`await ask_async`)~~
+- ~~[x] Streaming Support (`ask_stream` / `ask_stream_async`)~~
+- ~~[x] Provider Fallback (`fallback=[Groq()]`)~~
+- ~~[x] Structured Outputs (Pydantic Support)~~
 
 ---
 

{askai_python-0.4.0 → askai_python-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "askai-python"
-version = "0.4.0"
+version = "0.4.1"
 description = "AI Made Stupid Simple. Unified API for OpenAI, Groq, Google, Anthropic, and more."
 readme = "docs/PYPI_README.md"
 requires-python = ">=3.9"

askai_python-0.4.0/ask_ai/providers/openrouter_provider.py

@@ -1,66 +0,0 @@
-import os
-from typing import List, Dict, Any
-
-try:
-    import openai
-except ImportError:
-    openai = None
-
-from ..config import AdvancedConfig
-from ..exceptions import APIKeyError, ProviderError
-from .openai_provider import OpenAIProvider
-
-
-class OpenRouterProvider(OpenAIProvider):
-    """OpenRouter provider — routes to multiple models via OpenAI-compatible API."""
-
-    def __init__(self, api_key: str = None, model: str = None, **kwargs):
-        if openai is None:
-            raise ProviderError("OpenAI client library not installed. Run: pip install openai")
-
-        self.api_key = api_key or os.environ.get("OPENROUTER_API_KEY")
-        if not self.api_key:
-            raise APIKeyError("OpenRouter API Key is missing. Set OPENROUTER_API_KEY env var or pass api_key=")
-
-        # Sync client with OpenRouter base URL
-        self.client = openai.OpenAI(
-            base_url="https://openrouter.ai/api/v1",
-            api_key=self.api_key,
-        )
-        self._async_client = None
-
-        self.model = model or "openai/gpt-4o"
-        self.persona = None
-        self.config = AdvancedConfig(**kwargs)
-
-    @property
-    def async_client(self):
-        """Lazy-load async client for OpenRouter."""
-        if self._async_client is None:
-            self._async_client = openai.AsyncOpenAI(
-                base_url="https://openrouter.ai/api/v1",
-                api_key=self.api_key,
-            )
-        return self._async_client
-
-    def _get_api_key_env_var(self):
-        return "OPENROUTER_API_KEY"
-
-    def _get_default_model(self):
-        return "openai/gpt-4o"
-
-    def _get_media_tools(self) -> List[Dict[str, Any]]:
-        # OpenRouter does not support media endpoints
-        return []
-
-    def _generate_image(self, messages, config):
-        raise ProviderError("OpenRouter does not support Image Generation via this library.")
-
-    def _generate_audio(self, messages, config):
-        raise ProviderError("OpenRouter does not support Audio Generation via this library.")
-
-    async def _generate_image_async(self, messages, config):
-        raise ProviderError("OpenRouter does not support Image Generation via this library.")
-
-    async def _generate_audio_async(self, messages, config):
-        raise ProviderError("OpenRouter does not support Audio Generation via this library.")