gemini-agent-framework 0.2.3__tar.gz → 0.2.5__tar.gz

{gemini_agent_framework-0.2.3 → gemini_agent_framework-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gemini-agent-framework
-Version: 0.2.3
+Version: 0.2.5
 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://m7mdony.github.io/gemini-agent-framework

{gemini_agent_framework-0.2.3 → gemini_agent_framework-0.2.5}/docs/api_reference.md

@@ -120,15 +120,10 @@ The framework automatically maps Python types to Gemini JSON schema types:
 
 ## Response Structure
 
-The `response_structure` parameter in the `prompt` method allows you to define the expected structure of the response:
+The `json_format` parameter in the `prompt` method allows you to define the expected structure with in the prompt:
 
 ```python
-response_structure = {
-    "field_name": {
-        "type": "string|number|boolean|array|object",
-        "description": "Optional description"
-    }
-}
+Json_format = True
 ```
 
 ## Error Handling

{gemini_agent_framework-0.2.3 → gemini_agent_framework-0.2.5}/docs/best_practices.md

@@ -120,14 +120,10 @@ agent.set_variable('count', 5, 'Counter')
 
 ### 1. Structured Responses
 
-Define clear response structures:
+Define clear response structures within the prompt then apply them:
 
 ```python
-response_structure = {
-    'result': {'type': 'number', 'description': 'The calculation result'},
-    'steps': {'type': 'array', 'description': 'List of calculation steps'},
-    'explanation': {'type': 'string', 'description': 'Explanation of the calculation'}
-}
+json_format = True
 ```
 
 ### 2. Error Responses

{gemini_agent_framework-0.2.3 → gemini_agent_framework-0.2.5}/docs/tutorials.md

@@ -136,15 +136,11 @@ def safe_divide(a: float, b: float) -> float:
 ### 2. Using Response Structures
 
 ```python
-response_structure = {
-    'result': {'type': 'number', 'description': 'The calculation result'},
-    'steps': {'type': 'array', 'description': 'List of calculation steps'},
-    'explanation': {'type': 'string', 'description': 'Explanation of the calculation'}
-}
+
 
 response = agent.prompt(
-    "Calculate 15 * 7 and show your work",
-    response_structure=response_structure
+    """Calculate 15 * 7 and show your work respond with {"answer": number}""",
+    json_format=True
 )
 ```
 

{gemini_agent_framework-0.2.3 → gemini_agent_framework-0.2.5}/pyproject.toml

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

{gemini_agent_framework-0.2.3 → gemini_agent_framework-0.2.5}/src/gemini_agent/__init__.py

@@ -1,4 +1,4 @@
 from .agent import Agent
 
-__version__ = "0.2.3"
+__version__ = "0.2.5"
 __all__ = ["Agent"]

{gemini_agent_framework-0.2.3 → gemini_agent_framework-0.2.5}/src/gemini_agent/agent.py

@@ -328,7 +328,7 @@ class Agent:
         self,
         user_prompt: str,
         system_prompt: Optional[str] = None,
-        response_structure: Optional[Dict[str, Any]] = None,
+        json_format: bool = False,
         conversation_history: Optional[List[Dict[str, Any]]] = None,
         debug_scope: Optional[str] = [],
     ) -> Any:
@@ -338,15 +338,14 @@ class Agent:
         Args:
             user_prompt: The user's input prompt
             system_prompt: Optional system prompt to override the default
-            response_structure: Optional structure to enforce on the response
+            json_format: If True, response will be formatted as JSON. Default is False (plain text)
             conversation_history: Optional list of previous conversation turns
 
         Returns:
-            The model's response, processed according to the response structure if provided
+            The model's response, formatted as JSON if json_format is True, otherwise plain text
         """
         self._intermediate_results = {}
 
-
         current_contents = conversation_history if conversation_history else []
         
         # Add system instruction to payload
@@ -364,24 +363,16 @@ class Agent:
             payload["tools"] = [{"functionDeclarations": self._registered_tools_json}]
             payload["toolConfig"] = {"functionCallingConfig": {"mode": "AUTO"}}
 
-        apply_structure_later = bool(response_structure) and bool(self._registered_tools_json)
-        final_response_schema = None
-        final_mime_type = None
-
-        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"}},
-                }
+        # Don't set JSON formatting initially if tools are available
+        # We'll apply it later after tool calls are completed
+        apply_json_format_later = json_format and bool(self._registered_tools_json)
+        
+        # Set JSON formatting immediately if no tools are involved
+        if json_format and not self._registered_tools_json:
             payload["generationConfig"] = {
-                "response_mime_type": "application/json",
-                "response_schema": response_structure,
+                "response_mime_type": "application/json"
             }
-            final_mime_type = "application/json"
-            final_response_schema = response_structure
+
         count = 0
         while True:
             self._log_json(payload, f"payload_{count}.json", debug_scope)
@@ -410,8 +401,6 @@ class Agent:
                 content = candidate["content"]
 
                 for part in content["parts"]:
-                    
-
                     if "functionCall" in part:
                         payload["contents"].append({"role": "model", "parts": [part]})
                         fc = part["functionCall"]
@@ -500,41 +489,32 @@ class Agent:
                     elif "text" in part:
                         final_text = part["text"]
 
-                        if final_mime_type == "application/json" and final_response_schema:
-                            try:
-                                structured_output = json.loads(final_text)
-                                if not any(
-                                    "functionCall" in p
-                                    for p in content["parts"][content["parts"].index(part) + 1 :]
-                                ):
-                                    return structured_output
-                            except json.JSONDecodeError as e:
-                                self._log_text(
-                                    f"Warning: Failed to parse initially structured output: {e}. Continuing with raw text.",
-                                    debug_scope
-                                )
-
-                        elif apply_structure_later:
-                            if not any(
-                                "functionCall" in p
-                                for p in content["parts"][content["parts"].index(part) + 1 :]
-                            ):
-                                self._log_text("--- Attempting final structuring call ---", debug_scope)
-                                # Include the full conversation history in the formatting payload
+                        # Check if there are more function calls coming
+                        has_more_function_calls = any(
+                            "functionCall" in p
+                            for p in content["parts"][content["parts"].index(part) + 1 :]
+                        )
+
+                        if not has_more_function_calls:
+                            # If JSON format is requested and we have tools, make a final formatting call
+                            if apply_json_format_later:
+                                self._log_text("--- Making final JSON formatting call ---", debug_scope)
                                 formatting_payload = {
+                                    "system_instruction": {
+                                        "parts": [{"text": system_prompt if system_prompt else ""},{"text": self._get_system_prompt()}]
+                                    },
                                     "contents": payload["contents"] + [
                                         {
                                             "role": "user",
                                             "parts": [
                                                 {
-                                                    "text": f"Based on our conversation above, please format the following information according to the requested JSON structure:\n\n{final_text}"
+                                                    "text": f"Based on our conversation above, please format your response as JSON. Here is the current response: {final_text}"
                                                 }
                                             ],
                                         }
                                     ],
                                     "generationConfig": {
-                                        "response_mime_type": "application/json",
-                                        "response_schema": response_structure,
+                                        "response_mime_type": "application/json"
                                     },
                                 }
                                 self._log_json(formatting_payload, f"formatting_payload_{count}.json", debug_scope)
@@ -543,7 +523,7 @@ class Agent:
 
                                 if "error" in structured_response_data:
                                     self._log_text(
-                                        f"Structuring call failed: {structured_response_data['error']}. Returning intermediate text.",
+                                        f"JSON formatting call failed: {structured_response_data['error']}. Returning raw text.",
                                         debug_scope
                                     )
                                     return final_text
@@ -556,57 +536,24 @@ class Agent:
                                     return structured_output
                                 except (KeyError, IndexError, json.JSONDecodeError) as e:
                                     self._log_text(
-                                        f"Warning: Failed to parse structured output after formatting call: {e}. Returning intermediate text.",
+                                        f"Warning: Failed to parse JSON response after formatting call: {e}. Returning raw text.",
                                         debug_scope
                                     )
                                     return final_text
-
-                        elif not any(
-                            "functionCall" in p
-                            for p in content["parts"][content["parts"].index(part) + 1 :]
-                        ):
-                            if response_structure and not apply_structure_later:
-                                self._log_text("--- Attempting final structuring call ---", debug_scope)
-                                formatting_payload = {
-                                    "contents": [
-                                        {
-                                            "role": "user",
-                                            "parts": [
-                                                {
-                                                    "text": f"Please format the following information according to the requested JSON structure:\n\n{final_text}"
-                                                }
-                                            ],
-                                        }
-                                    ],
-                                    "generationConfig": {
-                                        "response_mime_type": "application/json",
-                                        "response_schema": response_structure,
-                                    },
-                                }
-                                self._log_json(formatting_payload, f"formatting_payload_{count}.json", debug_scope)
-                                count += 1
-                                structured_response_data = self._call_gemini_api(formatting_payload, debug_scope)
-
-                                if "error" in structured_response_data:
-                                    self._log_text(
-                                        f"Structuring call failed: {structured_response_data['error']}. Returning intermediate text."
-                                        , debug_scope
-                                    )
-                                    return final_text
-
+                            elif json_format:
+                                # Direct JSON formatting (no tools involved)
                                 try:
-                                    structured_text = structured_response_data["candidates"][0][
-                                        "content"
-                                    ]["parts"][0]["text"]
-                                    structured_output = json.loads(structured_text)
+                                    structured_output = json.loads(final_text)
                                     return structured_output
-                                except (KeyError, IndexError, json.JSONDecodeError) as e:
+                                except json.JSONDecodeError as e:
                                     self._log_text(
-                                        f"Warning: Failed to parse structured output after formatting call: {e}. Returning intermediate text.",
+                                        f"Warning: Failed to parse JSON response: {e}. Returning raw text.",
                                         debug_scope
                                     )
                                     return final_text
-                            return final_text
+                            else:
+                                # Return plain text response
+                                return final_text
                 continue
 
             except (KeyError, IndexError) as e:

{gemini_agent_framework-0.2.3 → gemini_agent_framework-0.2.5}/tests/test_agent.py

@@ -64,25 +64,7 @@ response = agent_prompt_with_key_rotation(
     agent,
     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)

{gemini_agent_framework-0.2.3 → gemini_agent_framework-0.2.5}/tests/test_class_methods.py

@@ -39,27 +39,6 @@ def test_class_methods():
     # 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)
 

{gemini_agent_framework-0.2.3 → gemini_agent_framework-0.2.5}/tests/test_variables.py

@@ -107,16 +107,14 @@ print("\nExample 1: Count inputs in home page")
 response = agent.prompt(
 
     user_prompt="How many input tags are in the home page?",
-    system_prompt="You are a tool that counts the number of input tags in an HTML page.",
-    debug_scope=["json"],
-    response_structure={
-        "type": "object",
-        "properties": {
-            "count": {"type": "integer"},
-            "input_types": {"type": "array", "items": {"type": "string"}}
-        },
-        "required": ["count", "input_types"]
-    }
+    system_prompt=""""You are a tool that counts the number of input tags in an HTML page.
+        make the response in this format
+        {
+        "count": number,
+        "input_types": [input1,input2 ..... ] }
+      
+        """,
+    json_format= True
 )
 print(json.dumps(response, indent=2))
 
@@ -124,13 +122,13 @@ print(json.dumps(response, indent=2))
 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"]
-    }
+     system_prompt="""
+        make the response in this format
+        {
+        "count": number,
+        "input_types": [input1,input2 ..... ] }
+      
+        """,
+    json_format= True
 )
 print(json.dumps(response, indent=2))