Rakenna oma agentti (gemini_agent.py)

from google import genai
from google.genai import types

# Lukee GEMINI_API_KEY:n ympäristöstä
client = genai.Client()

response = client.models.generate_content(
  model="gemini-3.6-flash",
  contents="Kerro yhdellä lauseella mitä teet.",
)
print(response.text)

response = client.models.generate_content(
  model="gemini-3.6-flash",
  contents=history,
  config=types.GenerateContentConfig(
      tools=[...],                                 # työkalusi
      automatic_function_calling={"disable": True},  # sinä ajat silmukan
  ),
)

def build_system_prompt() -> str:
  return """You are a helpful coding assistant.

Rules:
- Always explain your plan before acting
- Use tools to verify your work
- Never execute destructive commands
- If unsure, ask the user
- Maximum 3 attempts per subtask

Available tools will be provided as function declarations.
Use them when needed to accomplish the user's goal.
"""

def build_cli_function_declarations() -> list:
  return [
      {
          "name": "read_file",
          "description": "Read the contents of a file",
          "parameters": {
              "type": "object",
              "properties": {
                  "path": {
                      "type": "string",
                      "description": "Path to the file"
                  }
              },
              "required": ["path"],
          },
      },
      {
          "name": "write_file",
          "description": "Write content to a file",
          "parameters": {
              "type": "object",
              "properties": {
                  "path": {"type": "string"},
                  "content": {"type": "string"},
              },
              "required": ["path", "content"],
          },
      },
      {
          "name": "run_command",
          "description": "Run a shell command",
          "parameters": {
              "type": "object",
              "properties": {
                  "command": {"type": "string"},
              },
              "required": ["command"],
          },
      },
      {
          "name": "search_files",
          "description": "Search for pattern in files",
          "parameters": {
              "type": "object",
              "properties": {
                  "pattern": {"type": "string"},
                  "path": {"type": "string", "default": "."},
              },
              "required": ["pattern"],
          },
      },
  ]

BLOCKED_PATTERNS = [
  "rm -rf",
  "drop table",
  "delete from",
  "git push --force",
  "chmod 777",
  "curl | sh",
  "wget | sh",
]

BLOCKED_FILE_PATTERNS = [
  ".env",
  "credentials",
  "secrets",
  "private_key",
]

def is_command_blocked(command: str) -> bool:
  """Tarkista onko komento estetty."""
  lower = command.lower()
  return any(p in lower for p in BLOCKED_PATTERNS)

def is_file_blocked(path: str) -> bool:
  """Tarkista onko tiedostopolku estetty."""
  lower = path.lower()
  return any(p in lower for p in BLOCKED_FILE_PATTERNS)

ALLOWED_COMMANDS = {'git status', 'git diff', 'npm test', 'npm run lint'}

def is_command_allowed(command: str) -> bool:
  """Vain erikseen nimetyt komennot, tarkka vastaavuus."""
  return command.strip() in ALLOWED_COMMANDS

import subprocess
import json

def execute_tool(name: str, args: dict) -> dict:
  """Suorita työkalu turvallisesti."""

  if name == "read_file":
      path = args["path"]
      if is_file_blocked(path):
          return {"error": f"Access denied: {path}"}
      try:
          with open(path) as f:
              return {"content": f.read()[:10000]}  # Rajaa koko
      except Exception as e:
          return {"error": str(e)}

  elif name == "run_command":
      cmd = args["command"]
      if is_command_blocked(cmd):
          return {"error": f"Blocked command: {cmd}"}
      try:
          result = subprocess.run(
              cmd, shell=True,
              capture_output=True, text=True,
              timeout=30,  # Aikaraja
          )
          return {
              "returncode": result.returncode,
              "stdout": result.stdout[:5000],
              "stderr": result.stderr[:2000],
          }
      except subprocess.TimeoutExpired:
          return {"error": "Command timed out (30s)"}

  elif name == "search_files":
      cmd = f"grep -r '{args['pattern']}' {args.get('path', '.')} --include='*.py' --include='*.ts' -l"
      if is_command_blocked(cmd):
          return {"error": "Blocked"}
      result = subprocess.run(
          cmd, shell=True, capture_output=True, text=True, timeout=10
      )
      return {"files": result.stdout.strip().split("\n")}

  return {"error": f"Unknown tool: {name}"}