fyodorov-llm-agents 0.3.8__py3-none-any.whl → 0.3.9__py3-none-any.whl

fyodorov_llm_agents/instances/instance_model.py

@@ -0,0 +1,40 @@
+from pydantic import BaseModel, HttpUrl, Field
+import re
+
+MAX_TITLE_LENGTH = 80
+VALID_CHARACTERS_REGEX = r'^[a-zA-Z0-9\s.,!?:;\'"-]+$'
+
+class InstanceModel(BaseModel):
+    id: str = Field(None, alias='id')
+    agent_id: str # Links to AgentModel.id
+    title: str = ""
+    chat_history: list[dict] = []
+
+    def validate(self) -> bool:
+        try:
+            InstanceModel.validate_title(self.title)
+        except ValueError as e:
+            print("Instance model validation error:", e)
+            return False
+        else:
+            return True
+
+    def to_dict(self) -> dict:
+        data = {
+            'agent_id': str(self.agent_id),
+            'title': self.title,
+            'chat_history': self.chat_history,
+        }
+        if self.id is not None:
+            data['id'] = str(self.id)
+        return data
+
+    @staticmethod
+    def validate_title(title: str) -> str:
+        if not title:
+            raise ValueError('Title is required')
+        if len(title) > MAX_TITLE_LENGTH:
+            raise ValueError('Title exceeds maximum length')
+        if not re.match(VALID_CHARACTERS_REGEX, title):
+            raise ValueError('Title contains invalid characters')
+        return title

fyodorov_llm_agents/instances/{instance.py → instance_service.py}

@@ -1,14 +1,13 @@
 from datetime import datetime
 from supabase import Client
 from fyodorov_utils.config.supabase import get_supabase
-from models.instance import InstanceModel
-from fyodorov_llm_agents.agents.agent import Agent as AgentModel
 from .agent import Agent
-from .provider import Provider
+from .providers.provider_service import Provider
 
-from fyodorov_llm_agents.tools.mcp_tool_service import MCPTool as Tool
-from .model import LLM
-from models.model import LLMModel
+from fyodorov_llm_agents.agents.agent import Agent as AgentModel
+from fyodorov_llm_agents.models.llm_model import LLMModel
+from fyodorov_llm_agents.models.llm_service import LLM
+from fyodorov_llm_agents.instances.instance_model import InstanceModel
 
 supabase: Client = get_supabase()
 

fyodorov_llm_agents/models/llm_model.py

@@ -0,0 +1,46 @@
+from pydantic import BaseModel, HttpUrl
+from typing import Literal
+
+class LLMModel(BaseModel):
+    id: str | None = None
+    name: str
+    provider: str
+    params: dict | None = None
+    mode: str = 'chat'
+    base_model: str
+    input_cost_per_token: float | None = None
+    output_cost_per_token: float | None = None
+    max_tokens: int | None = None
+
+    def to_dict(self):
+        return {
+            'name': self.name,
+            'provider': self.provider,
+            'params': self.params,
+            'mode': self.mode,
+            'base_model': self.base_model,
+            'input_cost_per_token': self.input_cost_per_token,
+            'output_cost_per_token': self.output_cost_per_token,
+            'max_tokens': self.max_tokens
+        }
+
+    @staticmethod
+    def from_dict(data) -> 'LLMModel':
+        input_dict = {
+            "name": data['name'],
+            "provider": data['provider'],
+        }
+        if 'model_info' in data and 'base_model' in data['model_info']:
+            input_dict['base_model'] = data['model_info']['base_model']
+        if 'params' in data:
+            input_dict['params'] = data['params']
+        if 'mode' in data:
+            input_dict['mode'] = data['mode']
+        if 'input_cost_per_token' in data:
+            input_dict['input_cost_per_token'] = data['input_cost_per_token']
+        if 'output_cost_per_token' in data:
+            input_dict['output_cost_per_token'] = data['output_cost_per_token']
+        if 'max_tokens' in data:
+            input_dict['max_tokens'] = data['max_tokens']
+        print('Input dict for LLMModel:', input_dict)
+        return LLMModel(**input_dict)

fyodorov_llm_agents/models/llm_service.py

@@ -0,0 +1,97 @@
+
+from pydantic import BaseModel
+import re
+from datetime import datetime
+from models.model import LLMModel
+from .provider import Provider
+from supabase import Client
+from fyodorov_utils.config.supabase import get_supabase
+
+supabase: Client = get_supabase()
+
+class LLM(LLMModel):
+
+    @staticmethod
+    async def update_model_in_db(access_token: str, user_id: str, name: str, update: dict) -> dict:
+        if not user_id or not name:
+            raise ValueError('Model name and User ID is required')
+        try:
+            result = supabase.table('models').update(update).eq('user_id', user_id).eq('name', name).execute()
+            update = result.data[0]
+            print('Updated model:', update)
+            return update
+        except Exception as e:
+            print(f"Error updating model with user_id {user_id} and name {name} "
+                  f"and update {update} ")
+            raise e
+
+    @staticmethod
+    async def save_model_in_db(access_token: str, user_id: str, model: LLMModel) -> dict:
+        try:
+            supabase = get_supabase(access_token)
+            provider = await Provider.get_or_create_provider(access_token, user_id, model.provider)
+            model_dict = model.to_dict()
+            model_dict['provider'] = provider.id
+            model_dict['user_id'] = user_id
+            result = supabase.table('models').upsert(model_dict).execute()
+            model_dict = result.data[0]
+            return model_dict
+        except Exception as e:
+            print('Error saving model', str(e))
+            raise e
+
+    @staticmethod
+    async def delete_model_in_db(access_token: str, user_id: str, name: str, id: str) -> bool:
+        try:
+            supabase = get_supabase(access_token)
+            if id:
+                result = supabase.table('models').delete().eq('id', id).execute()
+            elif user_id and name:
+                result = supabase.table('models').delete().eq('user_id', user_id).eq('name', name).execute()
+            else:
+                raise ValueError('Some form of id is required to delete a model')
+            print('Deleted model', result.data)
+            return True
+        except Exception as e:
+            print('Error deleting model', str(e))
+            raise e
+
+    @staticmethod
+    async def get_model(access_token: str, user_id: str = None, name: str = None, id: str = None) -> LLMModel:
+        try:
+            supabase = get_supabase(access_token)
+            if id:
+                print(f"Getting model with id: {id}")
+                result = supabase.table('models').select('*').eq('id', id).execute()
+            elif user_id and name:
+                print(f"Getting model with name: {name} and user_id: {user_id}")
+                result = supabase.table('models').select('*').eq('user_id', user_id).eq('name', name).execute()
+            else:
+                raise ValueError('Some form of id is required to retrieve a model')
+            print('Fetched model', result)
+            if not result or not result.data:
+                return None
+            model_dict = result.data[0]
+            model_dict['id'] = str(model_dict['id'])
+            model_dict['provider'] = str(model_dict['provider'])
+            model = LLMModel(**model_dict)
+            return model
+        except Exception as e:
+            print('Error fetching model from db', str(e))
+            raise e
+
+    @staticmethod
+    async def get_models(limit: int = 10, created_at_lt: datetime = datetime.now()) -> [dict]:
+        try:
+            result = supabase.table('models') \
+                        .select('*') \
+                        .order('created_at', desc=True) \
+                        .limit(limit) \
+                        .lt('created_at', created_at_lt) \
+                        .execute()
+            data = result.data
+            print('Fetched models', data)
+            return data
+        except Exception as e:
+            print('Error fetching models', str(e))
+            raise e

fyodorov_llm_agents/providers/provider_model.py

@@ -0,0 +1,32 @@
+from pydantic import BaseModel, HttpUrl
+from typing import Literal
+
+Provider = Literal['openai', 'mistral', 'ollama', 'openrouter']
+
+class ProviderModel(BaseModel):
+    id: str | None = None
+    name: Provider
+    api_key: str | None = None
+    api_url: HttpUrl | None = None
+
+    def to_dict(self):
+        dict = {
+            'name': self.name.lower(),
+        }
+        if self.api_url is not None:
+            dict['api_url'] = str(self.api_url)
+        if self.api_key is not None:
+            dict['api_key'] = self.api_key
+        if self.id is not None:
+            dict['id'] = self.id
+        return dict
+
+    def from_dict(data):
+        name = data['name'] if 'name' in data else None
+        api_url = data['api_url'] if 'api_url' in data else None
+        api_key = data['api_key'] if 'api_key' in data else None
+        return ProviderModel(
+            name=name.lower(),
+            api_key=api_key,
+            api_url=api_url,
+        )

fyodorov_llm_agents/providers/provider_service.py

@@ -0,0 +1,138 @@
+from datetime import datetime
+from .provider_model import ProviderModel
+from supabase import Client
+from fyodorov_utils.config.supabase import get_supabase
+
+supabase: Client = get_supabase()
+
+
+class Provider(ProviderModel):
+
+    @staticmethod
+    async def update_provider_in_db(id: str, update: dict) -> dict:
+        if not id:
+            raise ValueError('Provider ID is required')
+        try:
+            result = supabase.table('providers').update(update).eq('id', id).execute()
+            update = result.data[0]
+            print('Updated provider:', update)
+            return update
+        except Exception as e:
+            print(f"Error updating provider with id {id} "
+                  f"and update {update} ")
+            raise e
+
+    @staticmethod
+    async def save_provider_in_db(access_token: str, provider: ProviderModel, user_id: str) -> dict:
+        try:
+            print('Access token for saving provider:', access_token)
+            supabase = get_supabase(access_token)
+            provider.name = provider.name.lower()
+            if not provider.api_url or provider.api_url == "":
+                if provider.name == "openai":
+                    provider.api_url = "https://api.openai.com/v1"
+                elif provider.name == "mistral":
+                    provider.api_url = "https://api.mistral.ai/v1"
+                elif provider.name == "ollama":
+                    provider.api_url = "http://localhost:11434/v1"
+                elif provider.name == "openrouter":
+                    provider.api_url = "https://openrouter.ai/api/v1"
+                else:
+                    raise ValueError('No URL provided when creating a provider')
+            print('Setting provider api_url to', provider.api_url)
+            provider_dict = provider.to_dict()
+            provider_dict['user_id'] = user_id
+            print('Provider dict before merging existing row:', provider_dict)
+            # Check if the provider already exists based on name and user_id
+            existing_provider = await Provider.get_provider(access_token, user_id, provider.name)
+            if existing_provider:
+                tmp = {**existing_provider.to_dict(), **provider_dict}
+                provider_dict = tmp
+            print('Saving provider', provider_dict)
+            result = supabase.table('providers').upsert(provider_dict).execute()
+            provider = result.data[0]
+            print('Saved provider', provider)
+            return provider
+        except Exception as e:
+            print('Error saving provider', str(e))
+            if e.code == '23505':
+                print('Provider already exists')
+                return provider
+            raise e
+
+    @staticmethod
+    async def delete_provider_in_db(id) -> bool:
+        if not id:
+            raise ValueError('Provider ID is required')
+        try:
+            result = supabase.table('providers').delete().eq('id', id).execute()
+            return True
+        except Exception as e:
+            print('Error deleting provider', str(e))
+            raise e
+
+    @staticmethod
+    async def get_provider_by_id(access_token: str, id: str) -> ProviderModel:
+        if not id:
+            raise ValueError('Provider ID is required')
+        try:
+            supabase = get_supabase(access_token)
+            result = supabase.table('providers').select('*').eq('id', id).limit(1).execute()
+            provider_dict = result.data[0]
+            print('Fetched provider', provider_dict)
+            provider_dict['id'] = str(provider_dict['id'])
+            provider = ProviderModel(**provider_dict)
+            return provider
+        except Exception as e:
+            print('Error fetching provider', str(e))
+            raise e
+
+    @staticmethod
+    async def get_provider(access_token: str, user_id: str, name: str) -> ProviderModel:
+        print(f"Getting provider with name: {name} and user_id: {user_id}")
+        if not name:
+            raise ValueError('Provider name is required')
+        if not user_id:
+            raise ValueError('User ID is required')
+        try:
+            supabase = get_supabase(access_token)
+            print('Got access token for getting provider:', access_token)
+            result = supabase.table('providers').select('*')\
+                .eq('user_id', user_id)\
+                .eq('name', name.lower())\
+                .limit(1).execute()
+            print('Result of getting provider:', result)
+            provider_dict = result.data[0]
+            print('Fetched provider', provider_dict)
+            provider_dict['id'] = str(provider_dict['id'])
+            provider = ProviderModel(**provider_dict)
+            return provider
+        except Exception as e:
+            print('Error fetching provider', str(e))
+            raise e
+
+    @staticmethod
+    async def get_or_create_provider(access_token: str, user_id: str, name: str) -> ProviderModel:
+        try:
+            provider = await Provider.get_provider(access_token, user_id, name)
+            return provider
+        except Exception as e:            
+            provider = ProviderModel(name=name.lower())
+            provider = await Provider.save_provider_in_db(access_token, provider, user_id)
+            return provider
+
+    @staticmethod
+    async def get_providers(limit: int = 10, created_at_lt: datetime = datetime.now()) -> [dict]:
+        try:
+            result = supabase.table('providers') \
+                        .select('*') \
+                        .order('created_at', desc=True) \
+                        .limit(limit) \
+                        .lt('created_at', created_at_lt) \
+                        .execute()
+            data = result.data
+            print('Fetched providers', data)
+            return data
+        except Exception as e:
+            print('Error fetching providers', str(e))
+            raise e

{fyodorov_llm_agents-0.3.8.dist-info → fyodorov_llm_agents-0.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fyodorov_llm_agents
-Version: 0.3.8
+Version: 0.3.9
 Summary: LLM agents for the Fyodorov AI suite
 Author-email: Daniel Ransom <02masseur.alibis@icloud.com>
 Project-URL: Homepage, https://github.com/FyodorovAI/fyodorov-llm-agents

fyodorov_llm_agents-0.3.9.dist-info/RECORD

@@ -0,0 +1,15 @@
+fyodorov_llm_agents/agents/agent.py,sha256=vVBCEBpG11m4ae11Mr94rF5TJpuBluI_loQPDTw734w,5044
+fyodorov_llm_agents/agents/openai.py,sha256=FA5RS7yn3JwvFA8PXju60XSYC_2oUZFNgBUzeIYtGv0,1154
+fyodorov_llm_agents/instances/instance_model.py,sha256=PQaoVSH9H4qp_wcLvyT_QgvNtwf9oehOxZaGI6mv1bA,1206
+fyodorov_llm_agents/instances/instance_service.py,sha256=5HCgnaE9cd2HR1HqZFADKozVHR5SRvGHvXTRSB5Qiq4,8250
+fyodorov_llm_agents/models/llm_model.py,sha256=aQtXtB7kRpnVdbPu-nmTGAaflbtKz3DPkgcckf1srsg,1645
+fyodorov_llm_agents/models/llm_service.py,sha256=613PLLGiDzkCfkVbt0XDlRwTQRL06QPyr9bfsbwQtPk,3989
+fyodorov_llm_agents/providers/provider_model.py,sha256=OyCK6WMRhyElsp88gILg0wso-OPHI7f55gEeypsJ7O0,957
+fyodorov_llm_agents/providers/provider_service.py,sha256=GST-NLV8aLPsvapQEvgT_qHGYu7IpS5Xsut60XFmD-g,5865
+fyodorov_llm_agents/tools/mcp_tool_model.py,sha256=i7oFZReVGZsHN2K8T7mCAGF4t92wMMIR9mCkRHUgKsI,4413
+fyodorov_llm_agents/tools/mcp_tool_service.py,sha256=9tDvSdKpEAOKKU5MHImUqTOc6MZyk1hEjs3GpzgQUsk,5542
+fyodorov_llm_agents/tools/tool.py,sha256=HyOk0X_3XE23sa8J-8UZx657tJ0sxwZWMbA4OPxXU6E,7940
+fyodorov_llm_agents-0.3.9.dist-info/METADATA,sha256=5dPcGRcYhgr6oKGL1AopHd2kPYLooD5oGM8O7HD2jps,550
+fyodorov_llm_agents-0.3.9.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+fyodorov_llm_agents-0.3.9.dist-info/top_level.txt,sha256=4QOslsBp8Gh7ng25DceA7fHp4KguTIdAxwURz97gH-g,20
+fyodorov_llm_agents-0.3.9.dist-info/RECORD,,

fyodorov_llm_agents-0.3.8.dist-info/RECORD

@@ -1,10 +0,0 @@
-fyodorov_llm_agents/agents/agent.py,sha256=vVBCEBpG11m4ae11Mr94rF5TJpuBluI_loQPDTw734w,5044
-fyodorov_llm_agents/agents/openai.py,sha256=FA5RS7yn3JwvFA8PXju60XSYC_2oUZFNgBUzeIYtGv0,1154
-fyodorov_llm_agents/instances/instance.py,sha256=edPOcn6qIB6Gnbr5d2_4HBaCk3sa8XYxfJPSHrcDLHE,8218
-fyodorov_llm_agents/tools/mcp_tool_model.py,sha256=i7oFZReVGZsHN2K8T7mCAGF4t92wMMIR9mCkRHUgKsI,4413
-fyodorov_llm_agents/tools/mcp_tool_service.py,sha256=9tDvSdKpEAOKKU5MHImUqTOc6MZyk1hEjs3GpzgQUsk,5542
-fyodorov_llm_agents/tools/tool.py,sha256=HyOk0X_3XE23sa8J-8UZx657tJ0sxwZWMbA4OPxXU6E,7940
-fyodorov_llm_agents-0.3.8.dist-info/METADATA,sha256=u-fvGhE1XF17eJcWQQNNbYSKq8sL1BV1yV9VFyMb878,550
-fyodorov_llm_agents-0.3.8.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-fyodorov_llm_agents-0.3.8.dist-info/top_level.txt,sha256=4QOslsBp8Gh7ng25DceA7fHp4KguTIdAxwURz97gH-g,20
-fyodorov_llm_agents-0.3.8.dist-info/RECORD,,