fyodorov-llm-agents 0.3.7__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_service.py

@@ -0,0 +1,162 @@
+from datetime import datetime
+from supabase import Client
+from fyodorov_utils.config.supabase import get_supabase
+from .agent import Agent
+from .providers.provider_service import Provider
+
+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()
+
+JWT = "eyJhbGciOiJIUzI1NiIsImtpZCI6Im14MmVrTllBY3ZYN292LzMiLCJ0eXAiOiJKV1QifQ.eyJhdWQiOiJhdXRoZW50aWNhdGVkIiwiZXhwIjoxNzA3MzI0MTMxLCJpYXQiOjE3MDczMjA1MzEsImlzcyI6Imh0dHBzOi8vbGptd2R2ZWZrZ3l4cnVjc2dla3cuc3VwYWJhc2UuY28vYXV0aC92MSIsInN1YiI6IjljYzYzOWQ0LWUwMzItNDM3Zi1hNWVhLTUzNDljZGE0YTNmZCIsImVtYWlsIjoiZGFuaWVsQGRhbmllbHJhbnNvbS5jb20iLCJwaG9uZSI6IiIsImFwcF9tZXRhZGF0YSI6eyJwcm92aWRlciI6ImVtYWlsIiwicHJvdmlkZXJzIjpbImVtYWlsIl19LCJ1c2VyX21ldGFkYXRhIjp7Imludml0ZV9jb2RlIjoiUkFOU09NIn0sInJvbGUiOiJhdXRoZW50aWNhdGVkIiwiYWFsIjoiYWFsMSIsImFtciI6W3sibWV0aG9kIjoicGFzc3dvcmQiLCJ0aW1lc3RhbXAiOjE3MDczMjA1MzF9XSwic2Vzc2lvbl9pZCI6ImE4MTM4NmE1LTUxZTUtNDkyMS04ZjM3LWMyYWE3ODlhZDRhZiJ9.NNZA2rm1IQQ9wAhpyC8taMqregRmy8I9oZgT0P5heBg"
+
+class Instance(InstanceModel):
+
+    async def chat_w_fn_calls(self, input: str = "", access_token: str = JWT, user_id: str = "") -> str:
+        agent: AgentModel = await Agent.get_in_db(access_token=access_token, id = self.agent_id)
+        model: LLMModel = await LLM.get_model(access_token, user_id, id = agent.modelid)
+        print(f"Model fetched via LLM.get_model in chat_w_fn_calls: {model}")
+        provider: Provider = await Provider.get_provider_by_id(access_token, id = model.provider)
+        prompt = f"{agent.prompt}\n\n{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
+        agent.prompt = prompt
+        agent.model = model.base_model
+        agent.api_key = provider.api_key
+        agent.api_url = provider.api_url
+        # for index, tool in enumerate(agent.tools):
+        #     if isinstance(tool, str):
+        #         agent.tools[index] = Tool.get_by_name_and_user_id(access_token, tool, user_id)
+        #         print(f"Tool fetched via Tool.get_by_name_and_user_id in chat_w_fn_calls: {agent.tools[index]}")
+        res = agent.call_with_fn_calling(input=input, history=self.chat_history)
+        self.chat_history.append({
+            "role": "user",
+            "content": input
+        })
+        self.chat_history.append({
+            "role": "assistant",
+            "content": res["answer"]
+        })
+        # Update history
+        await self.create_in_db(instance=self)
+        return res
+
+    @staticmethod
+    async def create_in_db(instance: InstanceModel) -> dict:
+        try:
+            existing_instance = Instance.get_by_title_and_agent(instance.title, instance.agent_id)
+            if existing_instance:
+                needs_update = False
+                for key, value in instance.to_dict().items():
+                    if value != existing_instance[key]:
+                        print(f"Instance {key} needs updating: {value} != {existing_instance[key]}")
+                        needs_update = True
+                        existing_instance[key] = value
+                if needs_update:
+                    print('Instance already exists, will update:', existing_instance)
+                    instance_dict = await Instance.update_in_db(existing_instance["id"], existing_instance)
+                else:
+                    print('Instance already exists and no update needed:', existing_instance)
+                    instance_dict = existing_instance
+            else:
+                print("Creating instance in DB:", instance.to_dict())
+                result = supabase.table('instances').upsert(instance.to_dict()).execute()
+                if not result or not result.data:
+                    print(f"Error creating instance in DB: {result}")
+                    raise ValueError('Error creating instance in DB')
+                print(f"Result of creating instance in DB: {result}")
+                instance_dict = result.data[0]
+            instance_dict["id"] = str(instance_dict["id"])
+            instance_dict["agent_id"] = str(instance_dict["agent_id"])
+            return instance_dict
+        except Exception as e:
+            print(f"An error occurred while creating instance: {e}")
+            if 'code' in e and e.code == '23505':
+                print('Instance already exists')
+                instance_dict = Instance.get_by_title_and_agent(instance.title, instance.agent_id)
+                return instance_dict
+            print('Error creating instance', str(e))
+            raise e
+
+    @staticmethod
+    async def update_in_db(id: str, instance: dict) -> InstanceModel:
+        if not id:
+            raise ValueError('Instance ID is required')
+        try:
+            print(f"Updating instance in DB with ID: {id}, data: {instance}")
+            result = supabase.table('instances').update(instance).eq('id', id).execute()
+            print(f"Result of update: {result}")
+            instance_dict = result.data[0]
+            instance_dict["id"] = str(instance_dict["id"])
+            return instance_dict
+        except Exception as e:
+            print('An error occurred while updating instance:', id, str(e))
+            raise
+
+    @staticmethod
+    async def delete_in_db(id: str) -> bool:
+        if not id:
+            raise ValueError('Instance ID is required')
+        try:
+            result = supabase.table('instances').delete().eq('id', id).execute()
+            print('Deleted instance', result)
+            if not result.data:
+                raise ValueError('Instance ID not found')
+            else:
+                return True
+        except Exception as e:
+            print('Error deleting instance', str(e))
+            raise e
+
+    @staticmethod
+    def get_by_title_and_agent(title: str, agent_id: str) -> dict:
+        if not title:
+            raise ValueError('Instance title is required')
+        if not agent_id:
+            raise ValueError('Agent ID is required')
+        try:
+            print(f"Fetching instance with title {title} and agent ID {agent_id}")
+            result = supabase.table('instances').select('*').eq('title', title).eq('agent_id', agent_id).limit(1).execute()
+            if not result or not result.data:
+                print(f"No instance found with the given title {title} and agent ID {agent_id}: {result}")
+                return None
+            instance_dict = result.data[0]
+            instance_dict["agent_id"] = str(instance_dict["agent_id"])
+            instance_dict["id"] = str(instance_dict["id"])
+            print(f"Fetched instance: {instance_dict}")
+            return instance_dict
+        except Exception as e:
+            print('[Instance.get_by_title_and_agent] Error fetching instance', str(e))
+            raise e
+
+    @staticmethod
+    def get_in_db(id: str) -> InstanceModel:
+        if not id:
+            raise ValueError('Instance ID is required')
+        try:
+            result = supabase.table('instances').select('*').eq('id', id).limit(1).execute()
+            instance_dict = result.data[0]
+            instance_dict["agent_id"] = str(instance_dict["agent_id"])
+            instance_dict["id"] = str(instance_dict["id"])
+            print(f"Fetched instance: {instance_dict}")
+            instance = InstanceModel(**instance_dict)
+            return instance
+        except Exception as e:
+            print('[Instance.get_in_db] Error fetching instance', str(e))
+            raise e
+
+    @staticmethod
+    def get_all_in_db(limit: int = 10, created_at_lt: datetime = datetime.now()) -> [InstanceModel]:
+        try:
+            result = supabase.from_('instances') \
+                .select("*") \
+                .limit(limit) \
+                .lt('created_at', created_at_lt) \
+                .order('created_at', desc=True) \
+                .execute()
+            instance_models = [InstanceModel(**{k: str(v) if not isinstance(v, list) else v for k, v in instance.items()}) for instance in result.data]
+            return instance_models
+        except Exception as e:
+            print('[Instance.get_all_in_db] Error fetching instances', str(e))
+            raise e

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.7.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.7
+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.7.dist-info/RECORD

@@ -1,9 +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/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.7.dist-info/METADATA,sha256=gaov2jthap8Qu8luUtqUOwKrKq0PlwdZhvHO25bQRMA,550
-fyodorov_llm_agents-0.3.7.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-fyodorov_llm_agents-0.3.7.dist-info/top_level.txt,sha256=4QOslsBp8Gh7ng25DceA7fHp4KguTIdAxwURz97gH-g,20
-fyodorov_llm_agents-0.3.7.dist-info/RECORD,,