From acbe20d4ca279fd72b002d03401a065fc60787ad Mon Sep 17 00:00:00 2001 From: wjmmk Date: Mon, 4 May 2026 09:56:46 -0500 Subject: [PATCH 01/10] Refactor AIAgent class to use genai.Client and update environment variable handling with google. --- runbook/02_agent_class.py | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/runbook/02_agent_class.py b/runbook/02_agent_class.py index c4e9122..9fc13d7 100644 --- a/runbook/02_agent_class.py +++ b/runbook/02_agent_class.py @@ -2,16 +2,22 @@ # requires-python = ">=3.12" # dependencies = [ # "anthropic", # type: ignore +# "dotenv>=0.9.9", +# "google-genai>=1.74.0", # "pydantic", # ] # /// +from dotenv import load_dotenv import os import sys from typing import List, Dict, Any -from anthropic import Anthropic +from google import genai +# from google.genai import types from pydantic import BaseModel +load_dotenv() + class Tool(BaseModel): name: str @@ -21,16 +27,16 @@ class Tool(BaseModel): class AIAgent: def __init__(self, api_key: str): - self.client = Anthropic(api_key=api_key) + self.client = genai.Client(api_key=api_key) self.messages: List[Dict[str, Any]] = [] self.tools: List[Tool] = [] print("Agent initialized") if __name__ == "__main__": - api_key = os.environ.get("ANTHROPIC_API_KEY") + api_key = os.getenv("GEMINI_API_KEY") if not api_key: - print("Error: ANTHROPIC_API_KEY not set") + print("Error: GEMINI_API_KEY not set") sys.exit(1) agent = AIAgent(api_key) @@ -38,4 +44,5 @@ def __init__(self, api_key: str): # export ANTHROPIC_API_KEY="your-api-key-here" # uv run runbook/02_agent_class.py # ``` -# Should print: Agent initialized +# Should print: Agent initializedcls + From b5f26b570a4a57b5137f3895e825a88bbcb34da1 Mon Sep 17 00:00:00 2001 From: wjmmk Date: Mon, 4 May 2026 09:57:00 -0500 Subject: [PATCH 02/10] Refactor AIAgent to use google.genai.Client and update environment variable handling for GEMINI_API_KEY --- runbook/03_define_tools.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/runbook/03_define_tools.py b/runbook/03_define_tools.py index cf8cdb0..58790d9 100644 --- a/runbook/03_define_tools.py +++ b/runbook/03_define_tools.py @@ -2,16 +2,22 @@ # requires-python = ">=3.12" # dependencies = [ # "anthropic", # type: ignore +# "dotenv>=0.9.9", +# "google-genai>=1.74.0", # "pydantic", # ] # /// +from dotenv import load_dotenv import os import sys from typing import List, Dict, Any -from anthropic import Anthropic +from google import genai +# from google.genai import types from pydantic import BaseModel +load_dotenv() + class Tool(BaseModel): name: str @@ -21,7 +27,7 @@ class Tool(BaseModel): class AIAgent: def __init__(self, api_key: str): - self.client = Anthropic(api_key=api_key) + self.client = genai.Client(api_key=api_key) self.messages: List[Dict[str, Any]] = [] self.tools: List[Tool] = [] self._setup_tools() @@ -83,9 +89,9 @@ def _setup_tools(self): if __name__ == "__main__": - api_key = os.environ.get("ANTHROPIC_API_KEY") + api_key = os.getenv("GEMINI_API_KEY") if not api_key: - print("Error: ANTHROPIC_API_KEY not set") + print("Error: GEMINI_API_KEY not set") sys.exit(1) agent = AIAgent(api_key) From 3054e6ae44f0025bd8448256bbec05dd2012186a Mon Sep 17 00:00:00 2001 From: wjmmk Date: Mon, 4 May 2026 09:57:08 -0500 Subject: [PATCH 03/10] Refactor AiAgent to use google.genai.Client and update environment variable handling for GEMINI_API_KEY --- runbook/04_implement_tool_execution.py | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/runbook/04_implement_tool_execution.py b/runbook/04_implement_tool_execution.py index 6e2c5c3..f405a8b 100644 --- a/runbook/04_implement_tool_execution.py +++ b/runbook/04_implement_tool_execution.py @@ -2,16 +2,22 @@ # requires-python = ">=3.12" # dependencies = [ # "anthropic", # type: ignore +# "dotenv>=0.9.9", +# "google-genai>=1.74.0", # "pydantic", # ] # /// +from dotenv import load_dotenv import os import sys from typing import List, Dict, Any -from anthropic import Anthropic +from google import genai +# from google.genai import types from pydantic import BaseModel +load_dotenv() + class Tool(BaseModel): name: str @@ -19,9 +25,9 @@ class Tool(BaseModel): input_schema: Dict[str, Any] -class AIAgent: +class AiAgent: def __init__(self, api_key: str): - self.client = Anthropic(api_key=api_key) + self.client = genai.Client(api_key=api_key) self.messages: List[Dict[str, Any]] = [] self.tools: List[Tool] = [] self._setup_tools() @@ -158,16 +164,16 @@ def _edit_file(self, path: str, old_text: str, new_text: str) -> str: if __name__ == "__main__": - api_key = os.environ.get("ANTHROPIC_API_KEY") + api_key = os.environ.get("GEMINI_API_KEY") if not api_key: - print("Error: ANTHROPIC_API_KEY not set") + print("Error: GEMINI_API_KEY not set") sys.exit(1) - agent = AIAgent(api_key) + agent = AiAgent(api_key) # Test the tools print(agent._list_files(".")) # ```bash -# export ANTHROPIC_API_KEY="your-api +# export GEMINI_API_KEY="your-api # uv run runbook/04_implement_tool_execution.py # ``` # Should print: From e73c1a50ef343555d2564a9c729242138e26ef1a Mon Sep 17 00:00:00 2001 From: wjmmk Date: Mon, 4 May 2026 09:57:20 -0500 Subject: [PATCH 04/10] Refactor AIAgent to use google.genai.Client and update chat method for Gemini API compatibility --- runbook/05_add_chat_method.py | 147 +++++++++++++++++++++------------- 1 file changed, 90 insertions(+), 57 deletions(-) diff --git a/runbook/05_add_chat_method.py b/runbook/05_add_chat_method.py index 4e602e7..b75419f 100644 --- a/runbook/05_add_chat_method.py +++ b/runbook/05_add_chat_method.py @@ -2,16 +2,22 @@ # requires-python = ">=3.12" # dependencies = [ # "anthropic", # type: ignore +# "dotenv>=0.9.9", +# "google-genai>=1.74.0", # "pydantic", # ] # /// +from dotenv import load_dotenv import os import sys from typing import List, Dict, Any -from anthropic import Anthropic +from google import genai +from google.genai import types from pydantic import BaseModel +load_dotenv() + class Tool(BaseModel): name: str @@ -21,7 +27,7 @@ class Tool(BaseModel): class AIAgent: def __init__(self, api_key: str): - self.client = Anthropic(api_key=api_key) + self.client = genai.Client(api_key=api_key) self.messages: List[Dict[str, Any]] = [] self.tools: List[Tool] = [] self._setup_tools() @@ -156,82 +162,109 @@ def _edit_file(self, path: str, old_text: str, new_text: str) -> str: return f"Error editing file: {str(e)}" def chat(self, user_input: str) -> str: - self.messages.append({"role": "user", "content": user_input}) - - tool_schemas = [ - { - "name": tool.name, - "description": tool.description, - "input_schema": tool.input_schema, - } - for tool in self.tools + # 1. Agregar mensaje del usuario al estilo Google + self.messages.append(types.Content(role="user", parts=[types.Part.from_text(text=user_input)])) + + # 2. Convertir tus herramientas al formato que Gemini entiende + gemini_tools = [ + types.Tool( + function_declarations=[ + types.FunctionDeclaration( + name=t.name, + description=t.description, + parameters=t.input_schema, + ) + ] + ) + for t in self.tools ] while True: try: - response = self.client.messages.create( - model="claude-sonnet-4-5-20250929", - max_tokens=4096, - messages=self.messages, - tools=tool_schemas, + # 3. Llamada a la API + response = self.client.models.generate_content( + #model="gemini-2.0-flash", # Modelo actual recomendado + model="gemini-3-flash-preview", + contents=self.messages, + config=types.GenerateContentConfig( + tools=gemini_tools, + ), ) - assistant_message = {"role": "assistant", "content": []} - - for content in response.content: - if content.type == "text": - assistant_message["content"].append( - { - "type": "text", - "text": content.text, - } - ) - elif content.type == "tool_use": - assistant_message["content"].append( - { - "type": "tool_use", - "id": content.id, - "name": content.name, - "input": content.input, - } - ) - - self.messages.append(assistant_message) - - tool_results = [] - for content in response.content: - if content.type == "tool_use": - result = self._execute_tool(content.name, content.input) - tool_results.append( - { - "type": "tool_result", - "tool_use_id": content.id, - "content": result, - } + # 4. Guardar la respuesta del modelo en el historial + # El SDK de Google permite añadir la respuesta directamente + self.messages.append(response.candidates[0].content) + + # 5. Revisar si el modelo quiere usar una herramienta + # En Google, esto viene en 'parts' como 'function_call' + found_tool_use = False + for part in response.candidates[0].content.parts: + if part.function_call: + found_tool_use = True + tool_call = part.function_call + + # Ejecutar la herramienta + print(f"RESPUESTA: Ejecutando herramienta 🔩{tool_call.name}🔩. \n") + result = self._execute_tool(tool_call.name, tool_call.args) + + # 6. Añadir el RESULTADO al historial (role: tool) + self.messages.append( + types.Content( + role="tool", + parts=[ + types.Part.from_function_response( + name=tool_call.name, + response={"result": result} + ) + ] + ) ) - if tool_results: - self.messages.append({"role": "user", "content": tool_results}) - else: - return response.content[0].text if response.content else "" + # Si no hubo llamadas a herramientas, retornamos el texto final + if not found_tool_use: + return response.text except Exception as e: - return f"Error: {str(e)}" + return f"Error en el flujo de Gemini: {str(e)}" + + # MÉTODOS DE AYUDA (Iguales a los tuyos) + def _execute_tool(self, tool_name: str, tool_input: Dict[str, Any]) -> str: + if tool_name == "read_file": return self._read_file(tool_input["path"]) + if tool_name == "list_files": return self._list_files(tool_input.get("path", ".")) + if tool_name == "edit_file": + return self._edit_file(tool_input["path"], tool_input.get("old_text", ""), tool_input["new_text"]) + return f"Unknown tool: {tool_name}" + + def _read_file(self, path: str) -> str: + try: + with open(path, "r", encoding="utf-8") as f: return f.read() + except Exception as e: return str(e) + + def _list_files(self, path: str) -> str: + try: return str(os.listdir(path)) + except Exception as e: return str(e) + + def _edit_file(self, path: str, old_text: str, new_text: str) -> str: + try: + with open(path, "w", encoding="utf-8") as f: f.write(new_text) + return "Success" + except Exception as e: return str(e) if __name__ == "__main__": - api_key = os.environ.get("ANTHROPIC_API_KEY") + api_key = os.environ.get("GEMINI_API_KEY") if not api_key: - print("Error: ANTHROPIC_API_KEY not set") + print("Error: GEMINI_API_KEY not set") sys.exit(1) agent = AIAgent(api_key) # Test chat - response = agent.chat("What files are in the current directory?") + response = agent.chat("¿Cuales archivos hay en el directorio actual?") + """ response = agent.chat("¿En qué puedes ayudarme?") """ print(response) # ```bash -# export ANTHROPIC_API_KEY="your-api +# export GEMINI_API_KEY="your-api # uv run runbook/05_add_chat_method.py # ``` # Should print a response from Claude listing the files in the directory From ecd5416561c5e86fb9b7bdf7b89121906dcdf3c2 Mon Sep 17 00:00:00 2001 From: wjmmk Date: Mon, 4 May 2026 09:57:36 -0500 Subject: [PATCH 05/10] Refactor AIAgent to use google.genai.Client and update API key handling for GEMINI_API_KEY --- runbook/06_create_interactive_cli.py | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/runbook/06_create_interactive_cli.py b/runbook/06_create_interactive_cli.py index 3bb4d56..fc1095d 100644 --- a/runbook/06_create_interactive_cli.py +++ b/runbook/06_create_interactive_cli.py @@ -2,18 +2,22 @@ # requires-python = ">=3.12" # dependencies = [ # "anthropic", # type: ignore +# "dotenv>=0.9.9", +# "google-genai>=1.74.0", # "pydantic", # ] # /// +from dotenv import load_dotenv import os import sys -import argparse # NEW -import logging from typing import List, Dict, Any -from anthropic import Anthropic +from google import genai +from google.genai import types from pydantic import BaseModel +load_dotenv() + # Set up logging logging.basicConfig( level=logging.INFO, @@ -34,7 +38,7 @@ class Tool(BaseModel): class AIAgent: def __init__(self, api_key: str): - self.client = Anthropic(api_key=api_key) + self.client = genai.Client(api_key=api_key) self.messages: List[Dict[str, Any]] = [] self.tools: List[Tool] = [] self._setup_tools() @@ -234,14 +238,14 @@ def main(): description="AI Code Assistant - A conversational AI agent with file editing capabilities" ) parser.add_argument( - "--api-key", help="Anthropic API key (or set ANTHROPIC_API_KEY env var)" + "--api-key", help="Anthropic API key (or set GEMINI_API_KEY env var)" ) args = parser.parse_args() - api_key = args.api_key or os.environ.get("ANTHROPIC_API_KEY") + api_key = args.api_key or os.environ.get("GEMINI_API_KEY") if not api_key: print( - "Error: Please provide an API key via --api-key or ANTHROPIC_API_KEY environment variable" + "Error: Please provide an API key via --api-key or GEMINI_API_KEY environment variable" ) sys.exit(1) @@ -282,7 +286,7 @@ def main(): # ```bash -# export ANTHROPIC_API_KEY="your-api-key-here" +# export GEMINI_API_KEY="your-api-key-here" # uv run runbook/06_create_interactive_cli.py # ``` # Should print: From 5bdb5dbca41bc9dcecaf53c17836a5c7631385fa Mon Sep 17 00:00:00 2001 From: wjmmk Date: Mon, 4 May 2026 09:57:45 -0500 Subject: [PATCH 06/10] Refactor AIAgent to use google.genai.Client and update API key handling for GEMINI_API_KEY --- runbook/07_add_personality.py | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/runbook/07_add_personality.py b/runbook/07_add_personality.py index df505eb..66c4192 100644 --- a/runbook/07_add_personality.py +++ b/runbook/07_add_personality.py @@ -2,18 +2,21 @@ # requires-python = ">=3.12" # dependencies = [ # "anthropic", # type: ignore +# "dotenv>=0.9.9", +# "google-genai>=1.74.0", # "pydantic", # ] # /// +from dotenv import load_dotenv import os import sys -import argparse -import logging from typing import List, Dict, Any -from anthropic import Anthropic +from google import genai +from google.genai import types from pydantic import BaseModel +load_dotenv() # Set up logging logging.basicConfig( level=logging.INFO, @@ -34,7 +37,7 @@ class Tool(BaseModel): class AIAgent: def __init__(self, api_key: str): - self.client = Anthropic(api_key=api_key) + self.client = genai.Client(api_key=api_key) self.messages: List[Dict[str, Any]] = [] self.tools: List[Tool] = [] self._setup_tools() @@ -235,14 +238,14 @@ def main(): description="AI Code Assistant - A conversational AI agent with file editing capabilities" ) parser.add_argument( - "--api-key", help="Anthropic API key (or set ANTHROPIC_API_KEY env var)" + "--api-key", help="Anthropic API key (or set GEMINI_API_KEY env var)" ) args = parser.parse_args() - api_key = args.api_key or os.environ.get("ANTHROPIC_API_KEY") + api_key = args.api_key or os.environ.get("GEMINI_API_KEY") if not api_key: print( - "Error: Please provide an API key via --api-key or ANTHROPIC_API_KEY environment variable" + "Error: Please provide an API key via --api-key or GEMINI_API_KEY environment variable" ) sys.exit(1) @@ -283,7 +286,7 @@ def main(): # ```bash -# export ANTHROPIC_API_KEY="your-api +# export GEMINI_API_KEY="your-api # uv run runbook/07_add_personality.py # ``` # AI Code Assistant From 420f0bbbde7d2cb336ac3436e41219c05cd8e79c Mon Sep 17 00:00:00 2001 From: wjmmk Date: Mon, 4 May 2026 11:35:17 -0500 Subject: [PATCH 07/10] Update tool execution and chat method tests for AiAgent and AIAgent --- runbook/04_implement_tool_execution.py | 3 ++- runbook/05_add_chat_method.py | 4 ++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/runbook/04_implement_tool_execution.py b/runbook/04_implement_tool_execution.py index f405a8b..b534b44 100644 --- a/runbook/04_implement_tool_execution.py +++ b/runbook/04_implement_tool_execution.py @@ -170,7 +170,8 @@ def _edit_file(self, path: str, old_text: str, new_text: str) -> str: sys.exit(1) agent = AiAgent(api_key) # Test the tools - print(agent._list_files(".")) + """ print(agent._list_files(".")) """ + print(agent._read_file("./01_basic_script.py")) # ```bash # export GEMINI_API_KEY="your-api diff --git a/runbook/05_add_chat_method.py b/runbook/05_add_chat_method.py index b75419f..818f68d 100644 --- a/runbook/05_add_chat_method.py +++ b/runbook/05_add_chat_method.py @@ -258,8 +258,8 @@ def _edit_file(self, path: str, old_text: str, new_text: str) -> str: sys.exit(1) agent = AIAgent(api_key) # Test chat - response = agent.chat("¿Cuales archivos hay en el directorio actual?") - """ response = agent.chat("¿En qué puedes ayudarme?") """ + """ response = agent.chat("¿Cuales archivos hay en el directorio actual?") """ + response = agent.chat("¿En qué puedes ayudarme?") print(response) From 3caa29de6efac6dd21612357a382697f269b37b3 Mon Sep 17 00:00:00 2001 From: wjmmk Date: Mon, 4 May 2026 14:04:12 -0500 Subject: [PATCH 08/10] Refactor AIAgent chat method for Gemini API compatibility and enhance tool execution handling --- runbook/06_create_interactive_cli.py | 126 +++++++++++++++++---------- 1 file changed, 78 insertions(+), 48 deletions(-) diff --git a/runbook/06_create_interactive_cli.py b/runbook/06_create_interactive_cli.py index fc1095d..77eb03f 100644 --- a/runbook/06_create_interactive_cli.py +++ b/runbook/06_create_interactive_cli.py @@ -11,6 +11,8 @@ from dotenv import load_dotenv import os import sys +import argparse +import logging from typing import List, Dict, Any from google import genai from google.genai import types @@ -173,65 +175,93 @@ def _edit_file(self, path: str, old_text: str, new_text: str) -> str: return f"Error editing file: {str(e)}" def chat(self, user_input: str) -> str: - self.messages.append({"role": "user", "content": user_input}) - - tool_schemas = [ - { - "name": tool.name, - "description": tool.description, - "input_schema": tool.input_schema, - } - for tool in self.tools + # 1. Agregar mensaje del usuario al estilo Google + self.messages.append(types.Content(role="user", parts=[types.Part.from_text(text=user_input)])) + + # 2. Convertir tus herramientas al formato que Gemini entiende + gemini_tools = [ + types.Tool( + function_declarations=[ + types.FunctionDeclaration( + name=t.name, + description=t.description, + parameters=t.input_schema, + ) + ] + ) + for t in self.tools ] while True: try: - response = self.client.messages.create( - model="claude-sonnet-4-5-20250929", - max_tokens=4096, - messages=self.messages, - tools=tool_schemas, + # 3. Llamada a la API + response = self.client.models.generate_content( + #model="gemini-2.0-flash", # Modelo actual recomendado + model="gemini-3-flash-preview", + contents=self.messages, + config=types.GenerateContentConfig( + tools=gemini_tools, + ), ) - assistant_message = {"role": "assistant", "content": []} - - for content in response.content: - if content.type == "text": - assistant_message["content"].append( - {"type": "text", "text": content.text} - ) - elif content.type == "tool_use": - assistant_message["content"].append( - { - "type": "tool_use", - "id": content.id, - "name": content.name, - "input": content.input, - } + # 4. Guardar la respuesta del modelo en el historial + # El SDK de Google permite añadir la respuesta directamente + self.messages.append(response.candidates[0].content) + + # 5. Revisar si el modelo quiere usar una herramienta + # En Google, esto viene en 'parts' como 'function_call' + found_tool_use = False + for part in response.candidates[0].content.parts: + if part.function_call: + found_tool_use = True + tool_call = part.function_call + + # Ejecutar la herramienta + print(f"RESPUESTA: Ejecutando herramienta 🔩{tool_call.name}🔩. \n") + result = self._execute_tool(tool_call.name, tool_call.args) + + # 6. Añadir el RESULTADO al historial (role: tool) + self.messages.append( + types.Content( + role="tool", + parts=[ + types.Part.from_function_response( + name=tool_call.name, + response={"result": result} + ) + ] + ) ) - self.messages.append(assistant_message) - - tool_results = [] - for content in response.content: - if content.type == "tool_use": - result = self._execute_tool(content.name, content.input) - tool_results.append( - { - "type": "tool_result", - "tool_use_id": content.id, - "content": result, - } - ) - - if tool_results: - self.messages.append({"role": "user", "content": tool_results}) - else: - return response.content[0].text if response.content else "" + # Si no hubo llamadas a herramientas, retornamos el texto final + if not found_tool_use: + return response.text except Exception as e: - return f"Error: {str(e)}" + return f"Error en el flujo de Gemini: {str(e)}" + + # MÉTODOS DE AYUDA (Iguales a los tuyos) + def _execute_tool(self, tool_name: str, tool_input: Dict[str, Any]) -> str: + if tool_name == "read_file": return self._read_file(tool_input["path"]) + if tool_name == "list_files": return self._list_files(tool_input.get("path", ".")) + if tool_name == "edit_file": + return self._edit_file(tool_input["path"], tool_input.get("old_text", ""), tool_input["new_text"]) + return f"Unknown tool: {tool_name}" + def _read_file(self, path: str) -> str: + try: + with open(path, "r", encoding="utf-8") as f: return f.read() + except Exception as e: return str(e) + + def _list_files(self, path: str) -> str: + try: return str(os.listdir(path)) + except Exception as e: return str(e) + + def _edit_file(self, path: str, old_text: str, new_text: str) -> str: + try: + with open(path, "w", encoding="utf-8") as f: f.write(new_text) + return "Success" + except Exception as e: return str(e) def main(): parser = argparse.ArgumentParser( From bac5ffdfdbdf147ca7dc667311968b0034068d99 Mon Sep 17 00:00:00 2001 From: wjmmk Date: Tue, 5 May 2026 08:49:19 -0500 Subject: [PATCH 09/10] Add argparse and logging imports to 07_add_personality.py for enhanced functionality --- runbook/07_add_personality.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/runbook/07_add_personality.py b/runbook/07_add_personality.py index 66c4192..1009538 100644 --- a/runbook/07_add_personality.py +++ b/runbook/07_add_personality.py @@ -11,6 +11,8 @@ from dotenv import load_dotenv import os import sys +import argparse +import logging from typing import List, Dict, Any from google import genai from google.genai import types From 4fb6b6b8e4cfc1835aa33eacb128a85c178cfd35 Mon Sep 17 00:00:00 2001 From: wjmmk Date: Thu, 7 May 2026 15:24:55 -0500 Subject: [PATCH 10/10] Refactor AIAgent methods for improved readability and error handling --- runbook/06_create_interactive_cli.py | 24 ++++++++++++++++-------- runbook/07_add_personality.py | 2 +- 2 files changed, 17 insertions(+), 9 deletions(-) diff --git a/runbook/06_create_interactive_cli.py b/runbook/06_create_interactive_cli.py index 77eb03f..5594975 100644 --- a/runbook/06_create_interactive_cli.py +++ b/runbook/06_create_interactive_cli.py @@ -242,26 +242,34 @@ def chat(self, user_input: str) -> str: # MÉTODOS DE AYUDA (Iguales a los tuyos) def _execute_tool(self, tool_name: str, tool_input: Dict[str, Any]) -> str: - if tool_name == "read_file": return self._read_file(tool_input["path"]) - if tool_name == "list_files": return self._list_files(tool_input.get("path", ".")) + if tool_name == "read_file": + return self._read_file(tool_input["path"]) + if tool_name == "list_files": + return self._list_files(tool_input.get("path", ".")) if tool_name == "edit_file": return self._edit_file(tool_input["path"], tool_input.get("old_text", ""), tool_input["new_text"]) return f"Unknown tool: {tool_name}" def _read_file(self, path: str) -> str: try: - with open(path, "r", encoding="utf-8") as f: return f.read() - except Exception as e: return str(e) + with open(path, "r", encoding="utf-8") as f: + return f.read() + except Exception as e: + return str(e) def _list_files(self, path: str) -> str: - try: return str(os.listdir(path)) - except Exception as e: return str(e) + try: + return str(os.listdir(path)) + except Exception as e: + return str(e) def _edit_file(self, path: str, old_text: str, new_text: str) -> str: try: - with open(path, "w", encoding="utf-8") as f: f.write(new_text) + with open(path, "w", encoding="utf-8") as f: + f.write(new_text) return "Success" - except Exception as e: return str(e) + except Exception as e: + return str(e) def main(): parser = argparse.ArgumentParser( diff --git a/runbook/07_add_personality.py b/runbook/07_add_personality.py index 1009538..59df9ee 100644 --- a/runbook/07_add_personality.py +++ b/runbook/07_add_personality.py @@ -15,7 +15,7 @@ import logging from typing import List, Dict, Any from google import genai -from google.genai import types +# from google.genai import types from pydantic import BaseModel load_dotenv()