openrouter-provider 0.1.1__py3-none-any.whl → 1.0.1__py3-none-any.whl

OpenRouterProvider/LLMs.py → llms.py

@@ -15,16 +15,25 @@ 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_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-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)
@@ -34,10 +43,12 @@ deepseek_v3_free = LLMModel(name='deepseek/deepseek-chat-v3-0324:free', input_co
 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 +56,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)
+

message.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from enum import Enum
+from io import BytesIO
+import base64
+from typing import Optional, Any
+
+from PIL import Image
+from openai.types.chat import ChatCompletion
+
+from .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
+    ) -> None:
+        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))

OpenRouterProvider/Chatbot_manager.py → openrouter.py

@@ -1,13 +1,16 @@
-from .Chat_message import *
-from .OpenRouterProvider import *
-from .LLMs import LLMModel
-
-from dotenv import load_dotenv
-import time
+from __future__ import annotations
 import json
+import time
 from typing import Iterator, AsyncIterator
+
+from dotenv import load_dotenv
 from pydantic import BaseModel
 
+from .llms import *
+from .message import *
+from .openrouter_provider import *
+from .tool import *
+
 
 _base_system_prompt = """
 It's [TIME] today.
@@ -18,79 +21,71 @@ You are an intelligent AI. You must follow the system_instruction below, which i
 </system_instruction>
 """
 
-class Chatbot_manager:
-    def __init__(self, system_prompt:str="", tools:list[tool_model]=[]) -> None:
+class OpenRouterClient:
+    def __init__(self, system_prompt: str = "", tools: list[tool_model] = None) -> None:
         load_dotenv()
         
-        self._memory: list[Chat_message] = []
-        self.tools: list[tool_model] = tools
-        self.set_system_prompt(prompt=system_prompt)
+        self._memory: list[Message] = []
+        self.tools: list[tool_model] = tools or []
+        self.set_system_prompt(system_prompt)
         
-    def set_system_prompt(self, prompt: str):
-        m, d, y = time.localtime()[:3]
+    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"{m}/{d}/{y}")
+        system_prompt = system_prompt.replace("[TIME]", f"{month}/{day}/{year}")
         system_prompt = system_prompt.replace("[SYSTEM_INSTRUCTION]", prompt)
         
-        self._system_prompt = Chat_message(text=system_prompt, role=Role.system)
+        self._system_prompt = Message(text=system_prompt, role=Role.system)
         
-    def clear_memory(self):
+    def clear_memory(self) -> None:
         self._memory = []
         
-    def print_memory(self):
-        print("\n--------------------- Chatbot memory ---------------------")
-        print(f"system   : {self._system_prompt.text}")
-
+    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()
             
-            reset_code = "\033[0m"
             role_str = f"{role.ljust(9)}:"
             indent = " " * len(role_str)
             lines = text.splitlines()
             
-            if role == "user":
-                color_code = "\033[94m"  # blue
-                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}")
+            color_codes = {
+                "user": "\033[94m",
+                "assistant": "\033[92m", 
+                "tool": "\033[93m",
+                "default": "\033[0m"
+            }
+            
+            color_code = color_codes.get(role, color_codes["default"])
             
-            elif role == "assistant":
-                color_code = "\033[92m"  # green
+            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":
-                color_code = "\033[93m"  # orange
                 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()
-                
-            else:
-                color_code = "\033[0m"   # default color
-                print("Print error: The role is invalid.")
-            
-        print("----------------------------------------------------------\n")
 
     def invoke(
-        self, 
-        model: LLMModel, 
-        query: Chat_message, 
-        tools: list[tool_model]=[], 
-        provider:ProviderConfig=None,
-        temperature: float=0.3
-    ) -> Chat_message:
+        self,
+        model: LLMModel,
+        query: Message,
+        tools: list[tool_model] = None,
+        provider: ProviderConfig = None,
+        temperature: float = 0.3
+    ) -> Message:
+        tools = tools or []
         self._memory.append(query)
         client = OpenRouterProvider()
         reply = client.invoke(
@@ -101,7 +96,7 @@ class Chatbot_manager:
             tools=self.tools + tools,
             provider=provider,
         )
-        reply.answeredBy = model
+        reply.answered_by = model
         self._memory.append(reply)
 
         if reply.tool_calls:
@@ -116,7 +111,6 @@ class Chatbot_manager:
                         requested_tool.result = result
                         break
                 else:
-                    print("Tool Not found", requested_tool.name)
                     return reply
                     
             reply = client.invoke(
@@ -127,19 +121,20 @@ class Chatbot_manager:
                 provider=provider
             )
             
-            reply.answeredBy = model
+            reply.answered_by = model
             self._memory.append(reply)
 
         return reply
     
     def invoke_stream(
-        self, 
-        model: LLMModel, 
-        query: Chat_message, 
-        tools: list[tool_model]=[], 
-        provider:ProviderConfig=None,
-        temperature: float=0.3
+        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(
@@ -156,16 +151,17 @@ class Chatbot_manager:
             text += token.choices[0].delta.content
             yield token.choices[0].delta.content
 
-        self._memory.append(Chat_message(text=text, role=Role.ai, answerdBy=LLMModel))
+        self._memory.append(Message(text=text, role=Role.ai, answered_by=model))
         
     async def async_invoke(
-        self, 
-        model: LLMModel, 
-        query: Chat_message, 
-        tools: list[tool_model] = [], 
+        self,
+        model: LLMModel,
+        query: Message,
+        tools: list[tool_model] = None,
         provider: ProviderConfig = None,
-        temperature: float=0.3
-    ) -> Chat_message:
+        temperature: float = 0.3
+    ) -> Message:
+        tools = tools or []
         self._memory.append(query)
         client = OpenRouterProvider()
         reply = await client.async_invoke(
@@ -176,7 +172,7 @@ class Chatbot_manager:
             tools=self.tools + tools,
             provider=provider
         )
-        reply.answeredBy = model
+        reply.answered_by = model
         self._memory.append(reply)
 
         if reply.tool_calls:
@@ -191,7 +187,6 @@ class Chatbot_manager:
                         requested_tool.result = result
                         break
                 else:
-                    print("Tool Not found", requested_tool.name)
                     return reply
 
             reply = await client.async_invoke(
@@ -201,19 +196,20 @@ class Chatbot_manager:
                 tools=self.tools + tools,
                 provider=provider
             )
-            reply.answeredBy = model
+            reply.answered_by = model
             self._memory.append(reply)
 
         return reply
 
     async def async_invoke_stream(
-        self, 
-        model: LLMModel, 
-        query: Chat_message, 
-        tools: list[tool_model] = [], 
+        self,
+        model: LLMModel,
+        query: Message,
+        tools: list[tool_model] = None,
         provider: ProviderConfig = None,
-        temperature: float=0.3
+        temperature: float = 0.3
     ) -> AsyncIterator[str]:
+        tools = tools or []
         self._memory.append(query)
         client = OpenRouterProvider()
 
@@ -232,15 +228,15 @@ class Chatbot_manager:
             text += delta
             yield delta
 
-        self._memory.append(Chat_message(text=text, role=Role.ai, answerdBy=model))
+        self._memory.append(Message(text=text, role=Role.ai, answered_by=model))
         
     def structured_output(
-        self, 
-        model: LLMModel, 
-        query: Chat_message, 
-        provider:ProviderConfig=None, 
-        json_schema: BaseModel=None,
-        temperature: float=0.3
+        self,
+        model: LLMModel,
+        query: Message,
+        provider: ProviderConfig = None,
+        json_schema: BaseModel = None,
+        temperature: float = 0.3
     ) -> BaseModel:
         self._memory.append(query)
         client = OpenRouterProvider()