openrouter-provider 0.0.5__py3-none-any.whl → 1.0.10__py3-none-any.whl

openrouter/__init__.py

@@ -0,0 +1,5 @@
+from .llms import *
+from .message import *
+from .openrouter import *
+from .openrouter_provider import *
+from .tool import *

OpenRouterProvider/LLMs.py → openrouter/llms.py

@@ -15,29 +15,39 @@ gpt_4_1_mini = LLMModel(name='openai/gpt-4.1-mini', input_cost=0.4, output_cost=
 gpt_4_1_nano = LLMModel(name='openai/gpt-4.1-nano', input_cost=0.1, output_cost=0.4)
 o4_mini = LLMModel(name='openai/o4-mini', input_cost=1.1, output_cost=4.4)
 o4_mini_high = LLMModel(name='openai/o4-mini-high', input_cost=1.1, output_cost=4.4)
-o3 = LLMModel(name='openai/o3', input_cost=10, output_cost=40)
+o3 = LLMModel(name='openai/o3', input_cost=2, output_cost=8)
+gpt_5_nano = LLMModel(name='openai/gpt-5-nano', input_cost=0.05, output_cost=0.4)
+gpt_5_mini = LLMModel(name='openai/gpt-5-mini', input_cost=0.25, output_cost=2)
+gpt_5 = LLMModel(name='openai/gpt-5', input_cost=1.25, output_cost=10)
+gpt_oss_20B_free = LLMModel(name='openai/gpt-oss-20b:free', input_cost=0, output_cost=0)
+gpt_oss_20B = LLMModel(name='openai/gpt-oss-20b', input_cost=0.06, output_cost=0.2)
+gpt_oss_120B = LLMModel(name='openai/gpt-oss-120b', input_cost=0.25, output_cost=0.69)
 
 # Anthropic
 claude_3_7_sonnet = LLMModel(name='anthropic/claude-3.7-sonnet', input_cost=3.0, output_cost=15.0)
 claude_3_7_sonnet_thinking = LLMModel(name='anthropic/claude-3.7-sonnet:thinking', input_cost=3.0, output_cost=15.0)
 claude_3_5_haiku = LLMModel(name='anthropic/claude-3.5-haiku', input_cost=0.8, output_cost=4.0)
+claude_4_sonnet = LLMModel(name='anthropic/claude-sonnet-4', input_cost=3.0, output_cost=15.0)
+claude_4_opus = LLMModel(name='anthropic/claude-opus-4', input_cost=15, output_cost=75)
+claude_4_1_opus = LLMModel(name='anthropic/claude-opus-4.1', input_cost=15, output_cost=75)
 
 # Google
 gemini_2_0_flash = LLMModel(name='google/gemini-2.0-flash-001', input_cost=0.1, output_cost=0.4)
-gemini_2_0_flash_free = LLMModel(name='google/gemini-2.0-flash-exp:free', input_cost=0.1, output_cost=0.4)
-gemini_2_5_flash = LLMModel(name='google/gemini-2.5-flash-preview', input_cost=0.15, output_cost=0.60)
-gemini_2_5_flash_thinking = LLMModel(name='google/gemini-2.5-flash-preview:thinking', input_cost=0.15, output_cost=3.5)
-gemini_2_5_pro = LLMModel(name='google/gemini-2.5-pro-preview-03-25', input_cost=1.25, output_cost=10)
+gemini_2_5_flash_lite = LLMModel(name='google/gemini-2.5-flash-lite', input_cost=0.1, output_cost=0.4)
+gemini_2_5_flash = LLMModel(name='google/gemini-2.5-flash', input_cost=0.3, output_cost=2.5)
+gemini_2_5_pro = LLMModel(name='google/gemini-2.5-pro', input_cost=1.25, output_cost=10)
 
 # Deepseek
 deepseek_v3_free = LLMModel(name='deepseek/deepseek-chat-v3-0324:free', input_cost=0, output_cost=0)
 deepseek_v3 = LLMModel(name='deepseek/deepseek-chat-v3-0324', input_cost=0.3, output_cost=1.2)
 deepseek_r1_free = LLMModel(name='deepseek/deepseek-r1:free', input_cost=0, output_cost=0)
 deepseek_r1 = LLMModel(name='deepseek/deepseek-r1', input_cost=0.5, output_cost=2.2)
+deepseek_v3_1 = LLMModel(name='deepseek/deepseek-chat-v3.1', input_cost=0.55, output_cost=1.68)
 
 # xAI
 grok_3_mini = LLMModel(name='x-ai/grok-3-mini-beta', input_cost=0.3, output_cost=0.5)
 grok_3 = LLMModel(name='x-ai/grok-3-beta', input_cost=3, output_cost=15)
+grok_4 = LLMModel(name='x-ai/grok-4', input_cost=3, output_cost=15)
 
 # Microsoft
 mai_ds_r1_free = LLMModel(name="microsoft/mai-ds-r1:free", input_cost=0, output_cost=0)
@@ -45,4 +55,5 @@ mai_ds_r1_free = LLMModel(name="microsoft/mai-ds-r1:free", input_cost=0, output_
 # Others
 llama_4_maverick_free = LLMModel(name="meta-llama/llama-4-maverick:free", input_cost=0, output_cost=0)
 llama_4_scout = LLMModel(name="meta-llama/llama-4-scout", input_cost=0.11, output_cost=0.34)
-mistral_small_3_1_24B_free = LLMModel(name="mistralai/mistral-small-3.1-24b-instruct:free", input_cost=0, output_cost=0)
+mistral_small_3_1_24B_free = LLMModel(name="mistralai/mistral-small-3.1-24b-instruct:free", input_cost=0, output_cost=0)
+

openrouter/message.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from enum import Enum
+from io import BytesIO
+import base64
+import uuid
+from typing import Optional, Any
+
+from PIL import Image
+from openai.types.chat import ChatCompletion
+
+from openrouter.llms import LLMModel
+
+
+class Role(Enum):
+    system = "system"
+    user = "user"
+    ai = "assistant"
+    agent = "agent"
+    tool = "tool"
+
+
+@dataclass
+class ToolCall:
+    id: str
+    name: str
+    arguments: dict
+    result: Any = ""
+
+
+class Message:
+    def __init__(
+        self,
+        text: str,
+        images: Optional[list[Image.Image]] = None,
+        role: Role = Role.user,
+        answered_by: Optional[LLMModel] = None,
+        raw_response: Optional[ChatCompletion] = None,
+        id: Optional[str] = None
+    ) -> None:
+        self.id = id if id is not None else str(uuid.uuid4())
+        self.role = role
+        self.text = text
+        self.images = self._process_image(images)
+        self.answered_by = answered_by
+        self.tool_calls: list[ToolCall] = []
+        self.raw_response = raw_response
+
+
+    def __str__(self) -> str:
+        BLUE = "\033[34m"
+        GREEN = "\033[32m"
+        RESET = "\033[0m"
+        
+        message = ""
+        
+        if self.role == Role.system:
+            message = "---------------------- System ----------------------\n"
+        elif self.role == Role.user:
+            message = BLUE + "----------------------- User -----------------------\n" + RESET
+        elif self.role == Role.ai:
+            message = GREEN + "--------------------- Assistant --------------------\n" + RESET
+        
+        message += self.text + RESET + "\n"
+        
+        return message
+        
+    def _process_image(self, images: Optional[list[Image.Image]]) -> Optional[list[str]]:
+        if images is None:
+            return None
+
+        base64_images = []
+        for image in images:
+            if image.mode == "RGBA":
+                image = image.convert("RGB")
+            
+            image = self._resize_image_aspect_ratio(image)
+            image = self._convert_to_base64(image)
+            base64_images.append(image)
+
+        return base64_images
+        
+    def _convert_to_base64(self, image: Image.Image) -> str:
+        buffered = BytesIO()
+        format_type = image.format if image.format else 'JPEG'
+        image.save(buffered, format=format_type)
+        img_bytes = buffered.getvalue()
+        img_base64 = base64.b64encode(img_bytes).decode('utf-8')
+        
+        return img_base64
+    
+    def _resize_image_aspect_ratio(self, image: Image.Image, target_length: int = 1024) -> Image.Image:
+        width, height = image.size
+        
+        if width > height:
+            new_width = target_length
+            new_height = int((target_length / width) * height)
+        else:
+            new_height = target_length
+            new_width = int((target_length / height) * width)
+
+        return image.resize((new_width, new_height))

openrouter/openrouter.py

@@ -0,0 +1,287 @@
+from __future__ import annotations
+import json
+import time
+from copy import deepcopy
+from typing import Iterator, AsyncIterator
+
+from dotenv import load_dotenv
+from pydantic import BaseModel
+
+from openrouter.llms import *
+from openrouter.message import *
+from openrouter.openrouter_provider import *
+from openrouter.tool import *
+
+
+_base_system_prompt = """
+It's [TIME] today.
+You are an intelligent AI. You must follow the system_instruction below, which is provided by the user.
+
+<system_instruction>
+[SYSTEM_INSTRUCTION]
+</system_instruction>
+"""
+
+class OpenRouterClient:
+    def __init__(self, system_prompt: str = "", tools: list[tool_model] = None) -> None:
+        load_dotenv()
+        
+        self._memory: list[Message] = []
+        self.tools: list[tool_model] = tools or []
+        self.set_system_prompt(system_prompt)
+        
+    def set_system_prompt(self, prompt: str) -> None:
+        month, day, year = time.localtime()[:3]
+
+        system_prompt = _base_system_prompt
+        system_prompt = system_prompt.replace("[TIME]", f"{month}/{day}/{year}")
+        system_prompt = system_prompt.replace("[SYSTEM_INSTRUCTION]", prompt)
+
+        self._system_prompt = Message(text=system_prompt, role=Role.system)
+
+    def _execute_tools(self, reply: Message, tools: list[tool_model]) -> Message:
+        if not reply.tool_calls:
+            return reply
+
+        reply_copy = deepcopy(reply)
+
+        for requested_tool in reply_copy.tool_calls:
+            args = requested_tool.arguments
+            if isinstance(args, str):
+                args = json.loads(args)
+
+            for tool in tools:
+                if tool.name == requested_tool.name:
+                    result = tool(**args)
+                    requested_tool.result = result
+                    break
+
+        return reply_copy
+
+    def execute_tool(self, reply: Message, tool_index: int, tools: List[tool_model] = []) -> Message:
+        if not reply.tool_calls:
+            return reply
+
+        if tool_index < 0 or tool_index >= len(reply.tool_calls):
+            raise IndexError(f"Tool index {tool_index} is out of range. Available tools: {len(reply.tool_calls)}")
+
+        requested_tool = reply.tool_calls[tool_index]
+
+        args = requested_tool.arguments
+        if isinstance(args, str):
+            args = json.loads(args)
+
+        all_tools = self.tools + tools
+        for tool in all_tools:
+            if tool.name == requested_tool.name:
+                result = tool(**args)
+                requested_tool.result = result
+                break
+        else:
+            raise ValueError(f"Tool '{requested_tool.name}' not found in registered tools")
+
+        for i, msg in enumerate(self._memory):
+            if msg.id == reply.id:
+                self._memory[i] = reply
+                break
+
+        return reply
+
+    def clear_memory(self) -> None:
+        self._memory = []
+        
+    def print_memory(self) -> None:
+        from tqdm import tqdm
+        
+        reset_code = "\033[0m"
+        
+        for message in self._memory:
+            role = message.role.value
+            text = message.text.strip()
+            
+            role_str = f"{role.ljust(9)}:"
+            indent = " " * len(role_str)
+            lines = text.splitlines()
+            
+            color_codes = {
+                "user": "\033[94m",
+                "assistant": "\033[92m", 
+                "tool": "\033[93m",
+                "default": "\033[0m"
+            }
+            
+            color_code = color_codes.get(role, color_codes["default"])
+            
+            if role in ["user", "assistant"]:
+                if lines:
+                    print(f"{color_code}{role_str}{reset_code} {lines[0]}")
+                    for line in lines[1:]:
+                        print(f"{color_code}{indent}{reset_code} {line}")
+                else:
+                    print(f"{color_code}{role_str}{reset_code}")
+            
+            elif role == "tool":
+                print(f"{color_code}{role_str}{reset_code} ", end="")
+                for tool in message.tool_calls:
+                    print(f"{tool.name}({json.loads(tool.arguments)}), ", end="")
+                print()
+
+    def invoke(
+        self,
+        model: LLMModel,
+        query: Message = None,
+        tools: list[tool_model] = None,
+        provider: ProviderConfig = None,
+        temperature: float = 0.3,
+        auto_tool_exec: bool = True
+    ) -> Message:
+        tools = tools or []
+        if query is not None:
+            self._memory.append(query)
+        client = OpenRouterProvider()
+
+        reply = client.invoke(
+            model=model,
+            temperature=temperature,
+            system_prompt=self._system_prompt,
+            querys=self._memory,
+            tools=self.tools + tools,
+            provider=provider,
+        )
+        reply.answered_by = model
+        self._memory.append(reply)
+
+        if auto_tool_exec and reply.tool_calls:
+            reply = self._execute_tools(reply, self.tools + tools)
+            self._memory[-1] = reply
+
+            reply = client.invoke(
+                model=model,
+                temperature=temperature,
+                system_prompt=self._system_prompt,
+                querys=self._memory,
+                provider=provider
+            )
+            reply.answered_by = model
+            self._memory.append(reply)
+
+        return reply
+    
+    def invoke_stream(
+        self,
+        model: LLMModel,
+        query: Message,
+        tools: list[tool_model] = None,
+        provider: ProviderConfig = None,
+        temperature: float = 0.3
+    ) -> Iterator[str]:
+        tools = tools or []
+        self._memory.append(query)
+        client = OpenRouterProvider()
+        generator = client.invoke_stream(
+            model=model,
+            temperature=temperature,
+            system_prompt=self._system_prompt,
+            querys=self._memory,
+            tools=self.tools + tools,
+            provider=provider
+        )
+        
+        text = ""
+        for token in generator:
+            text += token.choices[0].delta.content
+            yield token.choices[0].delta.content
+
+        self._memory.append(Message(text=text, role=Role.ai, answered_by=model))
+        
+    async def async_invoke(
+        self,
+        model: LLMModel,
+        query: Message = None,
+        tools: list[tool_model] = None,
+        provider: ProviderConfig = None,
+        temperature: float = 0.3,
+        auto_tool_exec: bool = True
+    ) -> Message:
+        tools = tools or []
+        if query is not None:
+            self._memory.append(query)
+        client = OpenRouterProvider()
+        reply = await client.async_invoke(
+            model=model,
+            temperature=temperature,
+            system_prompt=self._system_prompt,
+            querys=self._memory,
+            tools=self.tools + tools,
+            provider=provider
+        )
+        reply.answered_by = model
+        self._memory.append(reply)
+
+        if auto_tool_exec and reply.tool_calls:
+            reply = self._execute_tools(reply, self.tools + tools)
+
+            reply = await client.async_invoke(
+                model=model,
+                system_prompt=self._system_prompt,
+                querys=self._memory,
+                tools=self.tools + tools,
+                provider=provider
+            )
+            reply.answered_by = model
+            self._memory.append(reply)
+
+        return reply
+
+    async def async_invoke_stream(
+        self,
+        model: LLMModel,
+        query: Message,
+        tools: list[tool_model] = None,
+        provider: ProviderConfig = None,
+        temperature: float = 0.3
+    ) -> AsyncIterator[str]:
+        tools = tools or []
+        self._memory.append(query)
+        client = OpenRouterProvider()
+
+        stream = client.async_invoke_stream(
+            model=model,
+            temperature=temperature,
+            system_prompt=self._system_prompt,
+            querys=self._memory,
+            tools=self.tools + tools,
+            provider=provider
+        )
+
+        text = ""
+        async for chunk in stream:
+            delta = chunk.choices[0].delta.content or ""
+            text += delta
+            yield delta
+
+        self._memory.append(Message(text=text, role=Role.ai, answered_by=model))
+        
+    def structured_output(
+        self,
+        model: LLMModel,
+        query: Message,
+        provider: ProviderConfig = None,
+        json_schema: BaseModel = None,
+        temperature: float = 0.3
+    ) -> BaseModel:
+        self._memory.append(query)
+        client = OpenRouterProvider()
+        reply = client.structured_output(
+            model=model,
+            temperature=temperature,
+            system_prompt=self._system_prompt,
+            querys=self._memory,
+            provider=provider,
+            json_schema=json_schema
+        )
+        
+        self._memory.append(Message(text=reply.model_dump_json(), role=Role.ai, answered_by=model))
+        
+        return reply
+