gemini-agent-framework 0.1.1__tar.gz → 0.1.3__tar.gz

{gemini_agent_framework-0.1.1 → gemini_agent_framework-0.1.3}/.gitignore

@@ -2,4 +2,4 @@ __pycache__
 llama.log
 localllm.exe
 .env
-llm_test
+llm_test

{gemini_agent_framework-0.1.1 → gemini_agent_framework-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemini-agent-framework
-Version: 0.1.1
+Version: 0.1.3
 Summary: A framework for building agents that use Gemini's function calling capabilities
 Project-URL: Homepage, https://github.com/m7mdony/gemini-agent-framework
 Project-URL: Documentation, https://github.com/m7mdony/gemini-agent-framework#readme

{gemini_agent_framework-0.1.1 → gemini_agent_framework-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gemini-agent-framework"
-version = "0.1.1"
+version = "0.1.3"
 description = "A framework for building agents that use Gemini's function calling capabilities"
 readme = "README.md"
 requires-python = ">=3.8"

{gemini_agent_framework-0.1.1 → gemini_agent_framework-0.1.3}/src/gemini_agent/agent.py

@@ -4,6 +4,7 @@ import inspect
 from functools import wraps
 from typing import List, Callable, Dict, Any, Optional
 from dotenv import load_dotenv
+from datetime import datetime
 
 load_dotenv()
 
@@ -31,6 +32,7 @@ class Agent:
             Agent._tools_registry[func.__name__]['description'] = desc
             Agent._tools_registry[func.__name__]['signature'] = inspect.signature(func)
             Agent._tools_registry[func.__name__]['function_ref'] = func
+            Agent._tools_registry[func.__name__]['is_method'] = inspect.ismethod(func)
             @wraps(func)
             def wrapper(*args, **kwargs):
                 return func(*args, **kwargs)
@@ -48,6 +50,7 @@ class Agent:
                 Agent._tools_registry[func.__name__]['signature'] = inspect.signature(func)
             if 'function_ref' not in Agent._tools_registry[func.__name__]:
                 Agent._tools_registry[func.__name__]['function_ref'] = func
+            Agent._tools_registry[func.__name__]['is_method'] = inspect.ismethod(func)
             @wraps(func)
             def wrapper(*args, **kwargs):
                 return func(*args, **kwargs)
@@ -60,7 +63,7 @@ class Agent:
 
         Args:
             api_key: Your Google Generative AI API key.
-            tools: A list of Python functions decorated as tools.
+            tools: A list of Python functions or class methods decorated as tools.
             model_name: The name of the Gemini model to use.
         """
         if not api_key:
@@ -72,7 +75,9 @@ class Agent:
 
         self._registered_tools_json: List[Dict[str, Any]] = []  # Store JSON representation
         self._tool_functions: Dict[str, Callable] = {}  # Map name to actual function
+        self._tool_instances: Dict[str, Any] = {}  # Store instances for class methods
         self._intermediate_results: Dict[str, Any] = {}  # Store intermediate results
+        self._stored_variables: Dict[str, Dict[str, Any]] = {}  # Store variables with metadata
 
         if tools:
             self._process_tools(tools)
@@ -90,6 +95,12 @@ class Agent:
                 print(f"Warning: Function '{tool_name}' is missing @Agent.description. Skipping.")
                 continue
 
+            # Store the bound method directly if it's a class method
+            if inspect.ismethod(func):
+                self._tool_functions[tool_name] = func
+            else:
+                self._tool_functions[tool_name] = metadata['function_ref']
+
             # Build the parameters schema JSON
             gemini_params_schema = {
                 "type": "OBJECT",
@@ -102,6 +113,9 @@ class Agent:
             if not params_def and signature:
                 params_def = {}
                 for name, param in signature.parameters.items():
+                    # Skip 'self' parameter for class methods
+                    if name == 'self' and inspect.ismethod(func):
+                        continue
                     py_type = param.annotation if param.annotation != inspect.Parameter.empty else str
                     params_def[name] = {'type': py_type, 'description': f'Parameter {name}'}
 
@@ -125,10 +139,53 @@ class Agent:
                 del declaration_json["parameters"]
 
             self._registered_tools_json.append(declaration_json)
-            self._tool_functions[tool_name] = metadata['function_ref']
+
+    def set_variable(self, name: str, value: Any, description: str = "", type_hint: type = None) -> None:
+        """
+        Stores a variable in the agent's memory with metadata.
+
+        Args:
+            name: The name of the variable
+            value: The actual value to store
+            description: A description of what the variable represents
+            type_hint: Optional type hint for the variable
+        """
+        self._stored_variables[name] = {
+            'value': value,
+            'description': description,
+            'type': type_hint or type(value).__name__,
+            'created_at': datetime.now().isoformat()
+        }
+
+    def get_variable(self, name: str) -> Any:
+        """
+        Retrieves a stored variable's value.
+
+        Args:
+            name: The name of the variable to retrieve
+
+        Returns:
+            The stored value or None if not found
+        """
+        return self._stored_variables.get(name, {}).get('value')
+
+    def list_variables(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Returns information about all stored variables.
+
+        Returns:
+            Dictionary of variable names to their metadata
+        """
+        return {name: {k: v for k, v in data.items() if k != 'value'} 
+                for name, data in self._stored_variables.items()}
 
     def _get_system_prompt(self) -> str:
         """Returns a system prompt that guides the model in breaking down complex operations."""
+        variables_info = "\n".join([
+            f"- {name}: {data['description']} (Type: {data['type']})"
+            for name, data in self._stored_variables.items()
+        ])
+        
         return """You are an AI assistant that can break down complex tasks into sequential steps using available tools.
         When faced with a complex request:
         1. Analyze the request to identify which tools can be used
@@ -141,13 +198,49 @@ class Agent:
         Available tools:
         {tools_list}
         
+        Available variables:
+        {variables_list}
+        
+        IMPORTANT - Variable Usage:
+        When you need to use a stored variable in a function call, you MUST use the following syntax:
+        - For function arguments: {{"variable": "variable_name"}}
+        - For example, if you want to use the 'current_user' variable in a function call:
+          {{"user_id": {{"variable": "current_user"}}}}
+        
         Remember:
         - Always perform one operation at a time
         - Use intermediate results from previous steps
         - If a step requires multiple tools, execute them sequentially
         - If you're unsure about the next step, explain your reasoning
-        """.format(tools_list="\n".join([f"- {name}: {desc}" for name, desc in 
-            [(tool['name'], tool['description']) for tool in self._registered_tools_json]]))
+        - You can use both stored variables and values from the prompt
+        - When using stored variables, ALWAYS use the {{"variable": "variable_name"}} syntax
+        """.format(
+            tools_list="\n".join([f"- {name}: {desc}" for name, desc in 
+                [(tool['name'], tool['description']) for tool in self._registered_tools_json]]),
+            variables_list=variables_info
+        )
+
+    def _substitute_variables(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Substitutes stored variable values in function arguments.
+
+        Args:
+            args: Dictionary of argument names to values
+
+        Returns:
+            Dictionary with variable values substituted where applicable
+        """
+        substituted_args = {}
+        for name, value in args.items():
+            if isinstance(value, dict) and "variable" in value:
+                var_name = value["variable"]
+                if var_name in self._stored_variables:
+                    substituted_args[name] = self._stored_variables[var_name]['value']
+                else:
+                    substituted_args[name] = value
+            else:
+                substituted_args[name] = value
+        return substituted_args
 
     def _call_gemini_api(self, payload: Dict[str, Any]) -> Dict[str, Any]:
         """Makes a POST request to the Gemini generateContent endpoint."""
@@ -192,14 +285,14 @@ class Agent:
         self._intermediate_results = {}
         
         if not system_prompt:
-            system_prompt = self._get_system_prompt() + system_prompt
-        else:
             system_prompt = self._get_system_prompt()
+        else:
+            system_prompt = self._get_system_prompt() + system_prompt
 
         current_contents = conversation_history if conversation_history else []
         if system_prompt and not current_contents:
             current_contents.append({'role': 'user', 'parts': [{'text': system_prompt}]})
-            current_contents.append({'role': 'model', 'parts': [{'text': "I understand I should break down complex tasks into sequential steps using the available tools."}]})
+            current_contents.append({'role': 'model', 'parts': [{'text': "I understand I should break down complex tasks into sequential steps using the available tools and variables."}]})
 
         current_contents.append({'role': 'user', 'parts': [{'text': user_prompt}]})
         payload: Dict[str, Any] = {"contents": current_contents}
@@ -214,6 +307,14 @@ class Agent:
 
         if response_structure and not self._registered_tools_json:
             apply_structure_later = False
+            # If response_structure is a string type, make it more flexible
+            if response_structure.get("type") == "string":
+                response_structure = {
+                    "type": ["string", "object"],
+                    "properties": {
+                        "value": {"type": "string"}
+                    }
+                }
             payload["generationConfig"] = {
                 "response_mime_type": "application/json",
                 "response_schema": response_structure
@@ -223,7 +324,6 @@ class Agent:
 
         while True:
             response_data = self._call_gemini_api(payload)
-
             if "error" in response_data:
                 print(f"API call failed: {response_data['error'].get('message', 'Unknown API error')}")
                 return response_data
@@ -266,13 +366,17 @@ class Agent:
                             tool_function = self._tool_functions[tool_name]
                             print(f"--- Calling Function: {tool_name}({args}) ---")
                             
+                            # Substitute both stored variables and intermediate results
+                            args = self._substitute_variables(args)
                             for key, value in args.items():
                                 if isinstance(value, str) and value.startswith('$'):
                                     result_key = value[1:]
                                     if result_key in self._intermediate_results:
                                         args[key] = self._intermediate_results[result_key]
                             
+                            # Call the function directly - it's already bound if it's a method
                             function_result = tool_function(**args)
+                            
                             print(f"--- Function Result: {function_result} ---")
                             
                             result_key = f"result_{len(self._intermediate_results)}"

gemini_agent_framework-0.1.3/tests/__init__.py

@@ -0,0 +1,3 @@
+"""
+Test package for the Gemini Agent Framework.
+""" 

gemini_agent_framework-0.1.3/tests/test_agent.py

@@ -0,0 +1,66 @@
+import os
+from dotenv import load_dotenv
+from framework_agent import Agent
+
+load_dotenv()
+
+def test_basic_operations():
+    # Define some basic math operations
+    @Agent.description("Multiplies two numbers.")
+    @Agent.parameters({
+        'a': {'type': int, 'description': 'The first number'},
+        'b': {'type': int, 'description': 'The second number'}
+    })
+    def multiply(a: int, b: int) -> int:
+        return a * b
+
+    @Agent.description("Adds two numbers.")
+    @Agent.parameters({
+        'a': {'type': int, 'description': 'The first number'},
+        'b': {'type': int, 'description': 'The second number'}
+    })
+    def add(a: int, b: int) -> int:
+        return a + b
+
+    # Create an agent with the math tools
+    agent = Agent(
+        api_key=os.getenv("GEMINI_API_KEY"),
+        tools=[multiply, add]
+    )
+
+    # Test a simple multiplication
+    response = agent.prompt("Multiply 3 and 7")
+    print(f"Multiplication result: {response}")  # Should be 21
+
+    # Use the agent
+    response = agent.prompt(user_prompt="multiply 3 and 7 then add 5 to the result" ,
+    system_prompt="You are a helpful assistant give your response always with ❤️ at the start of the line. in your response you should mention the function you used." ,
+    response_structure=
+    {
+        "type": "object",
+        "properties": {
+            "used_functions": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "function_name": {"type": "string"},
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "a": {"type": "integer"},
+                                "b": {"type": "integer"}
+                            }
+                        }
+                    }
+                }
+            },
+            "answer": {"type": "string"}
+            
+        }
+    }
+    )
+    print(response)  # Should output 21
+
+if __name__ == "__main__":
+    test_basic_operations() 

gemini_agent_framework-0.1.3/tests/test_class_methods.py

@@ -0,0 +1,67 @@
+import os
+from dotenv import load_dotenv
+from gemini_agent import Agent
+
+load_dotenv()
+
+class Calculator:
+    def __init__(self):
+        self.memory = 0
+
+    @Agent.description("Multiplies a number by the stored memory value.")
+    @Agent.parameters({
+        'number': {'type': int, 'description': 'The number to multiply with memory'}
+    })
+    def multiply_with_memory(self, number: int) -> int:
+        result = self.memory * number
+        self.memory = result
+        return result
+
+    @Agent.description("Adds a number to the stored memory value.")
+    @Agent.parameters({
+        'number': {'type': int, 'description': 'The number to add to memory'}
+    })
+    def add_to_memory(self, number: int) -> int:
+        result = self.memory + number
+        self.memory = result
+        return result
+
+def test_class_methods():
+    # Create a calculator instance
+    calculator = Calculator()
+    
+    # Create an agent with the calculator methods
+    agent = Agent(
+        api_key=os.getenv("GEMINI_API_KEY"),
+        tools=[calculator.multiply_with_memory, calculator.add_to_memory]
+    )
+
+    # Test using class methods
+    response = agent.prompt(
+        "Multiply 5 with memory (starting at 0), then add 10 to the result",
+        response_structure={
+            "type": "object",
+            "properties": {
+                "used_functions": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "function_name": {"type": "string"},
+                            "parameters": {
+                                "type": "object",
+                                "properties": {
+                                    "number": {"type": "integer"}
+                                }
+                            }
+                        }
+                    }
+                },
+                "answer": {"type": "string"}
+            }
+        }
+    )
+    print(response)
+
+if __name__ == "__main__":
+    test_class_methods() 

gemini_agent_framework-0.1.3/tests/test_variables.py

@@ -0,0 +1,133 @@
+from agent import Agent
+import os
+from dotenv import load_dotenv
+import json
+from bs4 import BeautifulSoup
+
+load_dotenv()
+
+class HTMLAnalyzer:
+    @Agent.description("Count the number of input tags in an HTML page")
+    @Agent.parameters({
+        'html_content': {'type': str, 'description': 'The HTML content to analyze'}
+    })
+    def count_inputs(self, html_content: str) -> dict:
+        soup = BeautifulSoup(html_content, 'html.parser')
+        input_tags = soup.find_all('input')
+        return {
+            "count": len(input_tags),
+            "input_types": [tag.get('type', 'unknown') for tag in input_tags]
+        }
+
+# Create HTML pages
+home_page = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Home Page</title>
+</head>
+<body>
+    <header>
+        <nav>
+            <a href="/">Home</a>
+            <a href="/about">About</a>
+            <a href="/contact">Contact</a>
+        </nav>
+    </header>
+    <main>
+        <h1>Welcome to Our Website</h1>
+        <p>This is a simple home page with no input fields.</p>
+    </main>
+    <footer>
+        <p>&copy; 2024 Our Website</p>
+    </footer>
+</body>
+</html>
+"""
+
+login_page = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Login Page</title>
+</head>
+<body>
+    <header>
+        <nav>
+            <a href="/">Home</a>
+            <a href="/login">Login</a>
+        </nav>
+    </header>
+    <main>
+        <h1>Login</h1>
+        <form action="/login" method="POST">
+            <div>
+                <label for="username">Username:</label>
+                <input type="text" id="username" name="username" required>
+            </div>
+            <div>
+                <label for="password">Password:</label>
+                <input type="password" id="password" name="password" required>
+            </div>
+            <div>
+                <input type="checkbox" id="remember" name="remember">
+                <label for="remember">Remember me</label>
+            </div>
+            <button type="submit">Login</button>
+        </form>
+    </main>
+    <footer>
+        <p>&copy; 2024 Our Website</p>
+    </footer>
+</body>
+</html>
+"""
+
+# Create the analyzer instance
+html_analyzer = HTMLAnalyzer()
+
+# Create the agent with our tool
+agent = Agent(
+    api_key=os.getenv("GEMINI_API_KEY"),
+    tools=[html_analyzer.count_inputs]
+)
+
+# Store the HTML pages as variables
+agent.set_variable(
+    name="home_page",
+    value=home_page,
+    description="The HTML content of the home page",
+    type_hint=str
+)
+
+
+
+# Example 1: Count inputs in home page
+print("\nExample 1: Count inputs in home page")
+response = agent.prompt(
+    "How many input tags are in the home page?",
+    response_structure={
+        "type": "object",
+        "properties": {
+            "count": {"type": "integer"},
+            "input_types": {"type": "array", "items": {"type": "string"}}
+        },
+        "required": ["count", "input_types"]
+    }
+)
+print(json.dumps(response, indent=2))
+
+# Example 2: Count inputs in login page
+print("\nExample 2: Count inputs in login page")
+response = agent.prompt(
+    "How many input tags are in this page  "+ login_page,
+    response_structure={
+        "type": "object",
+        "properties": {
+            "count": {"type": "integer"},
+            "input_types": {"type": "array", "items": {"type": "string"}}
+        },
+        "required": ["count", "input_types"]
+    }
+)
+print(json.dumps(response, indent=2)) 

gemini_agent_framework-0.1.1/tests/test_agent.py

@@ -1,48 +0,0 @@
-import os
-from dotenv import load_dotenv
-from src.gemini_agent import Agent
-
-load_dotenv()
-
-def test_basic_operations():
-    # Define some basic math operations
-    @Agent.description("Multiplies two numbers.")
-    @Agent.parameters({
-        'a': {'type': int, 'description': 'The first number'},
-        'b': {'type': int, 'description': 'The second number'}
-    })
-    def multiply(a: int, b: int) -> int:
-        return a * b
-
-    @Agent.description("Adds two numbers.")
-    @Agent.parameters({
-        'a': {'type': int, 'description': 'The first number'},
-        'b': {'type': int, 'description': 'The second number'}
-    })
-    def add(a: int, b: int) -> int:
-        return a + b
-
-    # Create an agent with the math tools
-    agent = Agent(
-        api_key=os.getenv("GEMINI_API_KEY"),
-        tools=[multiply, add]
-    )
-
-    # Test a simple multiplication
-    response = agent.prompt("Multiply 3 and 7")
-    print(f"Multiplication result: {response}")  # Should be 21
-
-    # Test a complex operation
-    response = agent.prompt(
-        "Multiply 3 and 7, then add 4 to the result",
-        response_structure={
-            "type": "object",
-            "properties": {
-                "result": {"type": "number"}
-            }
-        }
-    )
-    print(f"Complex operation result: {response}")  # Should be {"result": 25}
-
-if __name__ == "__main__":
-    test_basic_operations()