drekai 0.1.0__tar.gz

drekai-0.1.0/.gitignore

@@ -0,0 +1,35 @@
+# Byte-compiled / optimized
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+build/
+dist/
+*.egg-info/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Testing / coverage
+.pytest_cache/
+htmlcov/
+.coverage
+.coverage.*
+
+# mypy / ruff
+.mypy_cache/
+.ruff_cache/
+
+# OS
+.DS_Store
+Thumbs.db

drekai-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 drek124
+
+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.

drekai-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+recursive-include assets *
+include LICENSE
+include README.md

drekai-0.1.0/PKG-INFO

@@ -0,0 +1,242 @@
+Metadata-Version: 2.5
+Name: drekai
+Version: 0.1.0
+Summary: A modern, async-first Python wrapper for OpenAI-compatible LLM APIs with built-in tool use.
+Project-URL: Homepage, https://github.com/drek124/drekai
+Project-URL: Repository, https://github.com/drek124/drekai
+Project-URL: Issues, https://github.com/drek124/drekai/issues
+Author-email: drek <drek.dev124@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,async,chat,llm,openai,tools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: openai>=1.0.0
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# DrekAI
+
+A modern, **async-first** Python wrapper for OpenAI-compatible LLM APIs with built-in **tool/function calling** support.
+
+> **Works with OpenAI, Gemini (via proxy), and any OpenAI-compatible endpoint.**
+
+---
+
+## ✨ Features
+
+- **Async-native** – built on `httpx` / `openai` async client
+- **Tool use** – define Python functions as AI-callable tools with automatic parameter injection
+- **Streaming** – stream responses token-by-token with a simple callback
+- **Sandboxed parameters** – keep secrets invisible to the LLM while still passing them to tools
+- **Multi-turn chats** – first-class conversation history management
+- **Image support** – send local files, URLs, or base64 images inline
+- **Thinking / reasoning** – support for extended-thinking models with effort control
+- **Gemini compatibility** – automatic tool-call shimming for Gemini models behind OpenAI proxies
+
+---
+
+## 📦 Installation
+
+```bash
+pip install drekai
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/drek124/drekai.git
+cd drekai
+pip install .
+```
+
+---
+
+## 🚀 Quick Start
+
+```python
+import asyncio
+from drekai import Model, Chatbot
+
+# 1. Define a model endpoint
+model = Model("gpt-4o", "https://api.openai.com/v1", api_key="sk-...")
+
+# 2. Create a chatbot
+bot = Chatbot(
+    name="Helper",
+    system_prompt="You are a helpful assistant.",
+    parent_model=model,
+    temperature=0.7,
+)
+
+async def main():
+    # One-shot generation
+    response = await bot.generate_text("Hello!")
+    print(response.choices[0].message.content)
+
+    # Multi-turn chat
+    chat = bot.start_chat()
+    r1 = await chat.generate_reply("What's the weather in Tokyo?")
+    r2 = await chat.generate_reply("And in London?")
+    print(r2.choices[0].message.content)
+
+asyncio.run(main())
+```
+
+---
+
+## 🛠️ Tool Use
+
+```python
+from drekai import Model, Chatbot
+from drekai.tools import Tool, ToolParameter
+
+model = Model("gpt-4o", "https://api.openai.com/v1", api_key="sk-...")
+bot = Chatbot("Assistant", "You are a helpful assistant.", model)
+
+async def get_weather(city: str) -> str:
+    """Get the current weather for a city."""
+    # In a real app, call a weather API here
+    return f"The weather in {city} is sunny, 25°C."
+
+tools = [
+    Tool(
+        "get_weather",
+        [ToolParameter("city", "City name", type=str)],
+        callback=get_weather,
+    )
+]
+
+async def main():
+    chat = bot.start_chat()
+    response = await chat.generate_reply(
+        "What's the weather in Paris?",
+        tools=tools,
+    )
+    print(response.choices[0].message.content)
+
+asyncio.run(main())
+```
+
+### Sandboxed Parameters
+
+Keep secrets like user IDs invisible to the LLM:
+
+```python
+async def get_friends(user, limit: int = 50) -> str:
+    """Fetch the user's friends list."""
+    return str(user.get_friends(limit=limit))
+
+tools = [
+    Tool(
+        "get_friends",
+        [ToolParameter("limit", "Max friends to return", required=False, type=int)],
+        callback=get_friends,
+        sandbox_params=["user"],  # hidden from the LLM
+    )
+]
+
+await chat.generate_reply(
+    "Who are my friends?",
+    tools=tools,
+    sandbox_params={"user": current_user},  # injected at call time
+)
+```
+
+---
+
+## 🖼️ Images
+
+```python
+from drekai.messaging import Image
+
+# Local file
+await chat.generate_reply(
+    "Describe this image.",
+    items=[Image("/path/to/photo.jpg")],
+)
+
+# URL
+await chat.generate_reply(
+    "Describe this image.",
+    items=[Image("https://example.com/photo.jpg")],
+)
+
+# Base64
+await chat.generate_reply(
+    "Describe this image.",
+    items=[Image(base64_data, b64=True)],
+)
+```
+
+---
+
+## 📖 API Reference
+
+### `Model(model_id, base_url, *, api_key)`
+Root model representing an API endpoint.
+
+### `Chatbot(name, system_prompt, parent_model, *, api_key, temperature, thinking, reasoning_effort)`
+A named chatbot built on a model.
+
+### `Chat`
+Created via `chatbot.start_chat()`. Manages conversation history.
+
+| Method | Description |
+|---|---|
+| `generate_reply(...)` | Generate the next response |
+| `add_message_to_context(content, role)` | Manually add a message |
+| `clear()` | Reset history (keeps system prompt) |
+| `delete_first_message(role)` | Remove first message with given role |
+| `stop_live_generation()` | Stop an active stream mid-generation |
+
+### `ChatSettings(max_tokens, show_tool_error_type)`
+Per-chat configuration.
+
+### `Tool(name, params, callback, sandbox_params)`
+An AI-callable function.
+
+### `ToolParameter(name, description, type, required)`
+Describes a tool parameter.
+
+### `MessageItem` / `Image`
+Chat message attachments.
+
+---
+
+## 🧪 Development
+
+```bash
+# Clone and install in editable mode with dev deps
+git clone https://github.com/drek124/drekai.git
+cd drekai
+pip install -e ".[dev]"
+
+# Lint
+ruff check .
+
+# Type check
+mypy .
+
+# Test
+pytest
+```
+
+---
+
+## 📄 License
+
+MIT License. See [LICENSE](LICENSE) for details.

drekai-0.1.0/README.md

@@ -0,0 +1,212 @@
+# DrekAI
+
+A modern, **async-first** Python wrapper for OpenAI-compatible LLM APIs with built-in **tool/function calling** support.
+
+> **Works with OpenAI, Gemini (via proxy), and any OpenAI-compatible endpoint.**
+
+---
+
+## ✨ Features
+
+- **Async-native** – built on `httpx` / `openai` async client
+- **Tool use** – define Python functions as AI-callable tools with automatic parameter injection
+- **Streaming** – stream responses token-by-token with a simple callback
+- **Sandboxed parameters** – keep secrets invisible to the LLM while still passing them to tools
+- **Multi-turn chats** – first-class conversation history management
+- **Image support** – send local files, URLs, or base64 images inline
+- **Thinking / reasoning** – support for extended-thinking models with effort control
+- **Gemini compatibility** – automatic tool-call shimming for Gemini models behind OpenAI proxies
+
+---
+
+## 📦 Installation
+
+```bash
+pip install drekai
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/drek124/drekai.git
+cd drekai
+pip install .
+```
+
+---
+
+## 🚀 Quick Start
+
+```python
+import asyncio
+from drekai import Model, Chatbot
+
+# 1. Define a model endpoint
+model = Model("gpt-4o", "https://api.openai.com/v1", api_key="sk-...")
+
+# 2. Create a chatbot
+bot = Chatbot(
+    name="Helper",
+    system_prompt="You are a helpful assistant.",
+    parent_model=model,
+    temperature=0.7,
+)
+
+async def main():
+    # One-shot generation
+    response = await bot.generate_text("Hello!")
+    print(response.choices[0].message.content)
+
+    # Multi-turn chat
+    chat = bot.start_chat()
+    r1 = await chat.generate_reply("What's the weather in Tokyo?")
+    r2 = await chat.generate_reply("And in London?")
+    print(r2.choices[0].message.content)
+
+asyncio.run(main())
+```
+
+---
+
+## 🛠️ Tool Use
+
+```python
+from drekai import Model, Chatbot
+from drekai.tools import Tool, ToolParameter
+
+model = Model("gpt-4o", "https://api.openai.com/v1", api_key="sk-...")
+bot = Chatbot("Assistant", "You are a helpful assistant.", model)
+
+async def get_weather(city: str) -> str:
+    """Get the current weather for a city."""
+    # In a real app, call a weather API here
+    return f"The weather in {city} is sunny, 25°C."
+
+tools = [
+    Tool(
+        "get_weather",
+        [ToolParameter("city", "City name", type=str)],
+        callback=get_weather,
+    )
+]
+
+async def main():
+    chat = bot.start_chat()
+    response = await chat.generate_reply(
+        "What's the weather in Paris?",
+        tools=tools,
+    )
+    print(response.choices[0].message.content)
+
+asyncio.run(main())
+```
+
+### Sandboxed Parameters
+
+Keep secrets like user IDs invisible to the LLM:
+
+```python
+async def get_friends(user, limit: int = 50) -> str:
+    """Fetch the user's friends list."""
+    return str(user.get_friends(limit=limit))
+
+tools = [
+    Tool(
+        "get_friends",
+        [ToolParameter("limit", "Max friends to return", required=False, type=int)],
+        callback=get_friends,
+        sandbox_params=["user"],  # hidden from the LLM
+    )
+]
+
+await chat.generate_reply(
+    "Who are my friends?",
+    tools=tools,
+    sandbox_params={"user": current_user},  # injected at call time
+)
+```
+
+---
+
+## 🖼️ Images
+
+```python
+from drekai.messaging import Image
+
+# Local file
+await chat.generate_reply(
+    "Describe this image.",
+    items=[Image("/path/to/photo.jpg")],
+)
+
+# URL
+await chat.generate_reply(
+    "Describe this image.",
+    items=[Image("https://example.com/photo.jpg")],
+)
+
+# Base64
+await chat.generate_reply(
+    "Describe this image.",
+    items=[Image(base64_data, b64=True)],
+)
+```
+
+---
+
+## 📖 API Reference
+
+### `Model(model_id, base_url, *, api_key)`
+Root model representing an API endpoint.
+
+### `Chatbot(name, system_prompt, parent_model, *, api_key, temperature, thinking, reasoning_effort)`
+A named chatbot built on a model.
+
+### `Chat`
+Created via `chatbot.start_chat()`. Manages conversation history.
+
+| Method | Description |
+|---|---|
+| `generate_reply(...)` | Generate the next response |
+| `add_message_to_context(content, role)` | Manually add a message |
+| `clear()` | Reset history (keeps system prompt) |
+| `delete_first_message(role)` | Remove first message with given role |
+| `stop_live_generation()` | Stop an active stream mid-generation |
+
+### `ChatSettings(max_tokens, show_tool_error_type)`
+Per-chat configuration.
+
+### `Tool(name, params, callback, sandbox_params)`
+An AI-callable function.
+
+### `ToolParameter(name, description, type, required)`
+Describes a tool parameter.
+
+### `MessageItem` / `Image`
+Chat message attachments.
+
+---
+
+## 🧪 Development
+
+```bash
+# Clone and install in editable mode with dev deps
+git clone https://github.com/drek124/drekai.git
+cd drekai
+pip install -e ".[dev]"
+
+# Lint
+ruff check .
+
+# Type check
+mypy .
+
+# Test
+pytest
+```
+
+---
+
+## 📄 License
+
+MIT License. See [LICENSE](LICENSE) for details.

drekai-0.1.0/__init__.py

@@ -0,0 +1,27 @@
+"""### DrekAI OpenAI API Wrapper
+
+Copyright (c) 2026 drek124
+
+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.
+"""
+from .chat import Chat
+from .model import Model, Chatbot
+from .settings import ChatSettings
+
+__all__ = ["Chat", "Chatbot", "Model", "ChatSettings"]

drekai-0.1.0/assets/.gitkeep

@@ -0,0 +1,2 @@
+# This directory is reserved for non-code assets such as images, icons,
+# or data files bundled with the drekai package.

drekai-0.1.0/chat.py

@@ -0,0 +1,255 @@
+import asyncio
+import random
+import string
+import json
+import traceback
+import logging
+from .tools import Tool
+from .messaging import MessageItem
+from .settings import ChatSettings
+from openai import HttpxBinaryResponseContent
+DEFAULT_OPTIONS = ChatSettings()
+
+class Chat:
+    def __init__(self, model, options):
+        self.model = model
+        self.messages: list[dict, dict] = [{
+                    "role": "system",
+                    "content": model.system_prompt
+                }]
+        self.total_tokens: int = 0
+        self.options: ChatSettings = options or DEFAULT_OPTIONS
+        self._stop_event: asyncio.Event | None = None
+        self.id: str = (self.model.id + '-' + ''.join(random.choice(string.ascii_lowercase) for _ in range(15))).upper()
+
+
+
+    def add_message_to_context(self, content: str, role: str = 'user') -> list[dict, dict]:
+        """Adds a message to the messages context."""
+        self.messages.append({
+            "role": role,
+            "content": str(content)
+        })
+        return self.messages
+
+    async def generate_reply(
+            self, prompt: str = None, prompt_role: str = 'user', *, thinking_callback = None, return_response_data: bool = True,
+            tools: list[Tool] = None, sandbox_params = {}, stream_callback = None, options: ChatSettings = None,
+            items: list[MessageItem] = [], 
+    ) -> HttpxBinaryResponseContent:
+        """## Response Generation
+        ### Parameters
+        - prompt: Add a prompt before generating
+        - prompt_role: The role of the prompt; such as `'user'`, `'system'` & `'assistant'`
+        - thinking_callback: The `async callback(thought: str)`; executed when a tool is called
+        - return_response_data: Whether to directly return the AI's response or the full API response.
+        - tools: The list of available tools
+        - sandbox_params: The sandboxed parameters that are invisible to the model; if a tool call from this request requires a certain sandboxed parameter, it will be fetched from here. (e.g. `{'user_id': user.id}`)
+        - stream_callback: `async callback(chunk: str)`; sets `stream` to `True`
+        - items: The list of chat items to insert in the message (e.g. images)
+        - options: The overwrite of the chat settings
+        """
+        
+        contents = [] + [item.value for item in items]
+        if prompt:
+            contents.append({"type": "text", "text": str(prompt)})
+
+        if contents:
+            self.messages.append({
+            "role": prompt_role,
+            "content": contents
+        })
+
+        params = {}
+
+        if not options:
+            options = self.options
+        
+        if options.max_tokens:
+            params['max_tokens'] = options.max_tokens
+        if self.model.parent_model.tool_compatability == 'gemini':
+           
+            for tool in tools:
+                if 'required' not in tool.raw.get('function', {}): 
+                    continue
+                preq = tool.raw['function']['required']
+                tool.raw['function']['parameters']['required'] = preq
+                tool.raw['function'].pop('required')
+
+
+        if tools:
+            params['tools'] = [tool.raw for tool in tools]
+
+        if not self.model.thinking:
+            params["extra_body"] = {
+            "thinking": {"type": "disabled"}
+        }
+
+        stream = True if stream_callback else False
+        
+
+        r = await self.model.client.chat.completions.create(
+        model=self.model.parent_model.id,
+        messages=self.messages,
+        stream=stream,
+        reasoning_effort=self.model.reasoning_effort, 
+        temperature=self.model.temperature, 
+        **params
+    )
+
+        if stream_callback:
+            full_content = ""
+            reasoning_content = ""
+            tool_calls_dict = {}
+            self._stop_event = asyncio.Event()
+            async for chunk in r:
+                if self._stop_event.is_set():
+                    await r.close()
+                    full_content += '\n[GENERATION_STOPPED]'
+                    assistant_msg = {"role": "assistant", "content": full_content}
+                    self.messages.append(assistant_msg)
+                    return assistant_msg if return_response_data else full_content
+                # Track token usage if included in stream
+                if chunk.usage:
+                    self.total_tokens += chunk.usage.total_tokens
+
+                if not chunk.choices:
+                    continue
+
+                delta = chunk.choices[0].delta
+
+                # 1. Accumulate text content & stream it
+                if delta.content:
+                    full_content += delta.content
+                    await stream_callback(delta.content)
+
+                if hasattr(delta, 'reasoning_content') and delta.reasoning_content:
+                    reasoning_content += delta.reasoning_content
+                    if thinking_callback:
+                        await thinking_callback(delta.reasoning_content)
+
+                # 3. Assemble streamed tool calls
+                if delta.tool_calls:
+                    for tc in delta.tool_calls:
+                        idx = tc.index
+                        if idx not in tool_calls_dict:
+                            tool_calls_dict[idx] = tc
+                        else:
+                            # Concatenate incoming argument chunks
+                            if tc.function and tc.function.arguments:
+                                tool_calls_dict[idx].function.arguments += tc.function.arguments
+
+            # Convert assembled tool calls to list
+            tool_calls = list(tool_calls_dict.values()) if tool_calls_dict else None
+            text_response = full_content
+
+            # Append assembled message to history
+            assistant_msg = {"role": "assistant", "content": full_content or None}
+            if tool_calls:
+                assistant_msg["tool_calls"] = [
+                    {
+                        "id": tc.id,
+                        "type": "function",
+                        "function": {
+                            "name": tc.function.name,
+                            "arguments": tc.function.arguments
+                        }
+                    }
+                    for tc in tool_calls
+                ]
+            self.messages.append(assistant_msg)
+
+        else:
+            # Non-streaming path
+            self.messages.append(r.choices[0].message)
+            self.total_tokens += r.usage.total_tokens
+            text_response = r.choices[0].message.content
+            tool_calls = r.choices[0].message.tool_calls
+            reasoning_content = getattr(r.choices[0].message, 'reasoning_content', None)
+
+
+        
+
+        # Tool Execution Phase
+        if tool_calls:
+            if getattr(self.model.parent_model, 'tool_compatability', None) == 'gemini':
+                # Convert Pydantic SDK object to dict if non-streaming
+                if not isinstance(self.messages[-1], dict) and hasattr(self.messages[-1], "model_dump"):
+                    self.messages[-1] = self.messages[-1].model_dump()
+
+                last_msg = self.messages[-1]
+
+                if isinstance(last_msg, dict) and "tool_calls" in last_msg:
+                    for tc in last_msg["tool_calls"]:
+                        # 1. Attach directly to tool call dict
+                        tc["thought_signature"] = "skip_thought_signature_validator"
+                        
+                        # 2. Attach to provider_specific_fields / extra_content (OpenAI proxy target)
+                        tc["extra_content"] = {"google": {"thought_signature": "skip_thought_signature_validator"}}
+            for ii, tc in enumerate(tool_calls, start=1):
+                tool = None
+                sandbox_params['_tc_index'] = ii # Add tool call index incase a tool needs it
+                for t in tools:
+                    if t.name == tc.function.name:
+                        tool = t
+                        break
+
+                args = json.loads(tc.function.arguments)
+                for sp in tool.sandbox_params:
+                    args[sp] = sandbox_params[sp]
+
+                if reasoning_content and thinking_callback:
+                    await thinking_callback(reasoning_content)
+                try:
+                    tool_response = await tool.callback(**args)
+                except Exception as e:
+                    tb = traceback.format_exc()
+                    tool_response = f"ERROR: {e}" if options.show_tool_error_type else "TOOL ERROR"
+                    logging.error(tb)
+                last_tool = (ii == len(tool_calls))
+                response = await self.tool_response(
+                    tc.id, 
+                    tool_response, 
+                    stream_callback=stream_callback,
+                    generate_response=last_tool, 
+                    sandbox_params=sandbox_params, 
+                    tools=tools
+                )
+
+                if not last_tool:
+                    continue
+
+            if return_response_data:
+                return response
+            
+            return text_response
+
+        return r if return_response_data else text_response
+
+
+    async def stop_live_generation(self):
+        "Stops the live generation"
+        self._stop_event.set()
+    
+    def clear(self):
+        """Wipes the chat; the system prompt doesn't get removed."""
+        self.messages = []
+        if self.model.system_prompt:
+                self.messages.append({
+                    "role": "system",
+                    "content": self.model.system_prompt
+                })
+
+    def delete_first_message(self, role: str):
+        """Deletes the first message in the context with the targeted role. System prompt cannot be deleted."""
+        for msg in self.messages:
+            if msg == self.messages[0]: continue
+            if msg['role'] != role: continue
+            self.messages.remove(msg)
+            break
+
+    async def tool_response(self, call_id: str, content, *, stream_callback, generate_response: bool = True, sandbox_params: dict = {}, tools = []):
+        self.messages.append({'role': 'tool', 'tool_call_id': call_id, 'content': str(content)})
+        if not generate_response: return
+        response = await self.generate_reply(return_response_data=True, tools=tools, sandbox_params=sandbox_params, stream_callback=stream_callback)
+        return response

drekai-0.1.0/messaging.py

@@ -0,0 +1,32 @@
+import base64
+from pathlib import Path
+
+class MessageItem:
+    def __init__(self, value: dict):
+        self.value: dict = value
+
+class Image(MessageItem):
+    def __init__(self, fp: str, *, b64: bool = False):
+        """Create an image ready to be appended to the chat
+        - fp: The local path of the image, or image URL.
+        - b64: `fp` representing the Base64 value of the image, not a path."""
+
+        if b64:
+            path = f"data:image/jpeg;base64,{fp}"
+
+        elif 'http' in fp.lower():
+            path = fp
+        else:
+            self.path: Path | str = Path(fp)
+            if not self.path.is_file():
+                raise ValueError(f"The file \"{self.path.name}\" not found")
+            with open(self.path, "rb") as image_file:
+                b64 = base64.b64encode(image_file.read()).decode("utf-8")
+                path = f"data:image/jpeg;base64,{b64}"
+                image_file.close()
+
+        super().__init__(value={
+                    "type": "image_url",
+                    "image_url": {
+                        "url": path
+                    }})

drekai-0.1.0/model.py

@@ -0,0 +1,59 @@
+from typing import Literal
+from . import Chat
+from openai import AsyncOpenAI, HttpxBinaryResponseContent
+MISSING = object()
+
+class Model:
+    def __init__(self, model_id: str, base_url: str, *, api_key = MISSING):
+        """Create a new root model
+        - id: The ID identified by the API endpoint, example: `drek-v6.7-pro`
+        - base_url: The URL of the OpenAI-supported endpoint
+        - api_key: The global API key for all child chatbots."""
+        self.id: str = model_id
+        self.base_url: str = base_url
+        if 'gemini' in self.id:
+            self.tool_compatability: str | None = 'gemini'
+        else:
+            self.tool_compatability: str = None
+        if api_key is not MISSING:
+            self.api_key = api_key  
+            self.client = AsyncOpenAI(api_key=api_key, base_url=base_url)
+        else:
+            self.api_key = None
+            self.client: AsyncOpenAI = None
+
+
+class Chatbot:
+    def __init__(
+            self, name: str, system_prompt: str, parent_model: Model, *,
+            api_key = MISSING, temperature: float = 1.0, thinking: bool = True, reasoning_effort: Literal['low', 'medium', 'high', 'max'] = 'low',
+            id = None
+            ):
+        """Create your new chatbot
+        ## Parameters
+        - name: The name of the chatbot; invisible to the LLM
+        - system_prompt: The system prompt for the chatbot
+        - parent_model: The root model that will be utilized
+        - temperature: The temperature represents the creativity/charm level of the model.
+        - api_key: Your authorized API key to the endpoint; if not present, `parent_model.api_key` will be utilized instead.
+        - thinking: The ability for the LLM to think
+        - reasoning_effort: When `thinking=True`, specify the effort the LLM would utilize to think
+        - id: Use it when needed for your own backend development"""
+        self.name: str = name
+        self.id = id if id is not None else self.name.lower().strip().replace(' ', '-')
+        self.parent_model: Model = parent_model
+        self.system_prompt = system_prompt
+        self.temperature: float = temperature
+        self.reasoning_effort: str = reasoning_effort
+        self.client = self.parent_model.client or AsyncOpenAI(api_key=api_key, base_url=parent_model.base_url)
+        self.thinking: bool = thinking
+    
+    async def generate_text(self, prompt: str, role: str = 'user', **kwargs) -> HttpxBinaryResponseContent:
+        """Generate a text response."""
+        chat = self.start_chat()
+        return await chat.generate_reply(prompt, role, **kwargs)
+
+    def start_chat(self) -> Chat:
+        "Start a new chat with the chatbot"
+        return Chat(self)
+       

drekai-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "drekai"
+version = "0.1.0"
+description = "A modern, async-first Python wrapper for OpenAI-compatible LLM APIs with built-in tool use."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "drek", email = "drek.dev124@gmail.com" },
+]
+keywords = ["openai", "llm", "chat", "tools", "async", "ai"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Typing :: Typed",
+]
+dependencies = [
+    "openai>=1.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/drek124/drekai"
+Repository = "https://github.com/drek124/drekai"
+Issues = "https://github.com/drek124/drekai/issues"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.23",
+    "ruff",
+    "mypy",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "UP", "B"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true

drekai-0.1.0/settings.py

@@ -0,0 +1,8 @@
+class ChatSettings:
+    def __init__(self, *, max_tokens: int = None, show_tool_error_type: bool = True):
+        """## DrekAI Chat Settings
+        ### Parameters
+        - max_tokens: The maximum input + output completion tokens allowed per response
+        - show_tool_error_type: Shows the LLM the exception that occured during the tool's execution; if `False`, the LLM recieves "TOOL ERROR". If `True`, the LLM recieves the exception message (Not traceback)."""
+        self.max_tokens = max_tokens
+        self.show_tool_error_type = show_tool_error_type

drekai-0.1.0/setup.py

@@ -0,0 +1,5 @@
+"""Backwards-compatible setup shim — all config lives in pyproject.toml."""
+
+from setuptools import setup
+
+setup()

drekai-0.1.0/tools/__init__.py

@@ -0,0 +1,4 @@
+"""### DrekAI Tools Wrapper"""
+from .tools import Tool, ToolParameter
+
+__all__ = ["Tool", "ToolParameter"]

drekai-0.1.0/tools/tools.py

@@ -0,0 +1,108 @@
+import inspect
+from types import NoneType
+from typing import Literal, Any
+
+TOOL_PARAM_CLASSES = {
+    str: "string",
+    float: "number",
+    int: "integer",
+    bool: "boolean",
+    dict: "object",
+    list: "array",
+    None: "null",
+    NoneType: "null"
+}
+
+class ToolParameter:
+    def __init__(self, name: str, description: str, *, required: bool = True,
+                  type: Any | Literal['string', 'number', 'integer', 'boolean',
+                                'object',  'array', 'null'] = str):
+        """## Tool Parameter
+        ## Parameters
+        - name: The name of the parameter; must match the present parameter in the callback.
+        - description: The description of this parameter that will be given to the LLM.
+        - type: The instance/object type of this parameter; Supported data types:
+        ```python 
+        str, int, float, bool, dict, list, None
+        ```
+        """
+        self.name: str = name
+        self.description: str = description
+        self.required: bool = required
+        if isinstance(type, str):
+            self.type: str = type
+        else:
+            if type not in TOOL_PARAM_CLASSES:
+                raise ValueError(f"Unknown tool parameter type \"{type}\"")
+            self.type: str = TOOL_PARAM_CLASSES[type]
+
+class Tool:
+    def __init__(
+            self, name: str, params: list[ToolParameter] = [], *,
+            callback = None, sandbox_params: list[str] = []
+                  ):
+        """## Create an AI Tool
+        ### Parameters
+        - name: The name of the tool
+        - params: The parameters of the tool
+        - callback: The callback of the tool; the description of the tool is decided by the callback's docs
+        - sandbox_params: The parameters hidden from the model and passed into the tool parameters.
+        By using sandboxed parameters, it makes it impossible for the AI to manage data it isn't supposed to manage.
+        Built-in sandbox parameters: 
+          - `_tc_index`: The index of the tool call
+        ### Example
+        *Creating a tool that fetches a user's friends*      
+        ```python
+        from DrekAI import Chatbot
+        from DrekAI.tools import Tool, ToolParameter
+
+        assistant = Chatbot("Assistant", "You are a helpful assistant")
+        chat = assistant.start_chat()
+
+        async def get_friends(user, limit: int = 100) -> str:
+            "Fetch the user's friends list" # The description passed to the LLM
+            result: str | Any = user.get_friends(limit=limit)
+            return "Friends list:" + result # The data returned to the LLM
+        tools = [
+            Tool(
+                "get_friends", [ToolParameter("limit", "The limit of the fetched users", required=False, type=int)],
+                callback=get_friends,
+                sandbox_params=["user"] # Accepted sandboxed parameters
+                )
+        ]
+
+        user = ...
+        async def main():
+            response = await chat.generate_reply("Who is in my friend's list?", 
+            tools=tools,
+            sandbox_params={"user": user} # Impossible for the LLM to fetch another user's friends
+            )
+            print(response.choices[0].message.content)
+        
+        ```"""
+        self.name: str = name
+        self.params: list[ToolParameter] = params
+        self.sandbox_params: list[str] = sandbox_params
+        if callback:
+            self.callback = callback
+        self.description: str = inspect.getdoc(self.callback)
+        self.raw: dict = {
+            'type': 'function',
+            'function': {
+                'name': self.name,
+                'description': self.description,
+                'parameters': {
+                    'type': 'object',
+                    'properties': {}
+                },
+                'required': [p.name for p in self.params if p.required]
+
+            }
+        }
+        for tool in self.params:
+            self.raw['function']['parameters']['properties'][tool.name] = {'type': tool.type, 'description': tool.description}
+
+        
+
+    async def callback(self, **kwargs) -> str:
+        raise NotImplementedError(f"Tool callback for \"{self.name}\" not implemented")