# Google ADK
pip install google-adk

# OpenTelemetry packages
pip install opentelemetry-sdk opentelemetry-exporter-otlp

# OpenInference instrumentation for ADK (if available)
pip install openinference-instrumentation-google-adk

<!-- For Maven -->
<dependency>
    <groupId>com.google.ai</groupId>
    <artifactId>google-adk</artifactId>
    <version>latest</version>
</dependency>

// For Gradle
implementation 'com.google.ai:google-adk:latest'

export OTEL_EXPORTER_OTLP_ENDPOINT="https://api.orq.ai/v2/otel"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <ORQ_API_KEY>"
export OTEL_RESOURCE_ATTRIBUTES="service.name=google-adk-app,service.version=1.0.0"
export GOOGLE_API_KEY="your-google-api-key"

$env:OTEL_EXPORTER_OTLP_ENDPOINT = "https://api.orq.ai/v2/otel"
$env:OTEL_EXPORTER_OTLP_HEADERS = "Authorization=Bearer <ORQ_API_KEY>"
$env:OTEL_RESOURCE_ATTRIBUTES = "service.name=google-adk-app,service.version=1.0.0"
$env:GOOGLE_API_KEY = "your-google-api-key"

OTEL_EXPORTER_OTLP_ENDPOINT=https://api.orq.ai/v2/otel
OTEL_EXPORTER_OTLP_HEADERS=Authorization=Bearer <ORQ_API_KEY>
OTEL_RESOURCE_ATTRIBUTES=service.name=google-adk-app,service.version=1.0.0
GOOGLE_API_KEY=your-google-api-key

pip install openinference-instrumentation-google-adk

from openinference.instrumentation.google_adk import GoogleADKInstrumentor
from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk.resources import Resource
import os

# Initialize OpenTelemetry
resource = Resource.create({
    "service.name": os.getenv("OTEL_SERVICE_NAME", "google-adk-app"),
    "service.version": "1.0.0"
})

provider = TracerProvider(resource=resource)
processor = BatchSpanProcessor(
    OTLPSpanExporter(
        endpoint=os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT"),
        headers={"Authorization": f"Bearer {os.getenv('ORQ_API_KEY')}"}
    )
)
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

# Instrument Google ADK
GoogleADKInstrumentor().instrument()

# Now use ADK normally - all agent operations will be traced
import google.adk as adk

# Your ADK agent code here

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
import google.adk as adk
import os

# Initialize OpenTelemetry
resource = Resource.create({
    "service.name": os.getenv("OTEL_SERVICE_NAME", "google-adk-app"),
    "service.version": "1.0.0"
})

provider = TracerProvider(resource=resource)
processor = BatchSpanProcessor(OTLPSpanExporter())
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

tracer = trace.get_tracer("google-adk")

# Wrapper for tracing agent operations
def trace_agent_run(agent, input_data):
    """Run an agent with OpenTelemetry tracing"""
    with tracer.start_as_current_span("adk.agent.run") as span:
        try:
            # Add attributes
            span.set_attributes({
                "agent.type": type(agent).__name__,
                "agent.input": str(input_data)[:200],  # First 200 chars
                "agent.model": getattr(agent, "model", "unknown")
            })
            
            # Run the agent
            result = agent.run(input_data)
            
            # Track success
            span.set_attribute("agent.success", True)
            span.set_attribute("agent.output.length", len(str(result)))
            
            return result
            
        except Exception as e:
            span.record_exception(e)
            span.set_attribute("agent.success", False)
            raise

import google.adk as adk
from google.adk.agents import LLMAgent

# Create a simple LLM agent
agent = LLMAgent(
    model="gemini-pro",
    system_prompt="You are a helpful assistant that answers questions concisely."
)

# Run the agent with tracing
response = agent.run("What is the capital of France?")
print(response)

from google.adk.agents import WorkflowAgent, SequentialAgent
from google.adk.tools import WebSearchTool, SummaryTool

# Create a workflow with sequential steps
workflow = SequentialAgent([
    WebSearchTool(),
    SummaryTool()
])

# Create workflow agent
agent = WorkflowAgent(
    workflow=workflow,
    model="gemini-pro"
)

# Execute workflow
result = agent.run("Find recent news about renewable energy and summarize")
print(result)

from google.adk.agents import ParallelAgent
from google.adk.tools import WebSearchTool, WikipediaTool, NewsTool

# Create parallel workflow for multi-source research
parallel_agent = ParallelAgent([
    WebSearchTool(),
    WikipediaTool(),
    NewsTool()
])

# Execute parallel research
results = parallel_agent.run("climate change impacts")
for source, data in results.items():
    print(f"{source}: {data[:200]}...")

from google.adk.agents import MultiAgent, LLMAgent

# Create specialized agents
researcher = LLMAgent(
    model="gemini-pro",
    system_prompt="You are a research specialist. Find and analyze information."
)

writer = LLMAgent(
    model="gemini-pro",
    system_prompt="You are a technical writer. Create clear documentation."
)

reviewer = LLMAgent(
    model="gemini-pro",
    system_prompt="You are an editor. Review and improve content."
)

# Create multi-agent system
multi_agent = MultiAgent({
    "research": researcher,
    "write": writer,
    "review": reviewer
})

# Orchestrate multi-agent workflow
task = "Create a technical guide about quantum computing"
research_data = multi_agent.agents["research"].run(f"Research: {task}")
draft = multi_agent.agents["write"].run(f"Write based on: {research_data}")
final = multi_agent.agents["review"].run(f"Review and improve: {draft}")

print(final)

from google.adk.tools import Tool
from google.adk.agents import LLMAgent

class WeatherTool(Tool):
    """Custom tool for weather information"""
    
    def __init__(self):
        super().__init__(
            name="weather",
            description="Get current weather for a location"
        )
    
    def run(self, location: str) -> str:
        # Simulated weather API call
        return f"The weather in {location} is sunny and 72°F"

# Create agent with custom tool
agent = LLMAgent(
    model="gemini-pro",
    tools=[WeatherTool()]
)

response = agent.run("What's the weather like in San Francisco?")
print(response)

from google.adk.agents import LoopAgent

# Create loop agent for iterative refinement
loop_agent = LoopAgent(
    agent=LLMAgent(model="gemini-pro"),
    max_iterations=3,
    condition=lambda x: "satisfactory" not in x.lower()
)

# Run iterative improvement
result = loop_agent.run(
    "Generate a product description for a smartwatch. "
    "Refine until it's satisfactory."
)
print(result)

from google.adk.agents import LLMAgent
from google.adk.memory import ConversationMemory

# Create agent with conversation memory
memory = ConversationMemory(max_turns=10)

agent = LLMAgent(
    model="gemini-pro",
    memory=memory,
    system_prompt="You are a helpful assistant with memory of our conversation."
)

# Have a conversation
agent.run("My name is Alice and I work in robotics")
agent.run("What field do I work in?")  # Agent remembers context

from opentelemetry import trace

tracer = trace.get_tracer("google-adk-error-handling")

def safe_agent_execution(agent, task):
    """Execute agent with comprehensive error handling and tracing"""
    with tracer.start_as_current_span("adk.safe_execution") as span:
        try:
            # Set task context
            span.set_attributes({
                "task.description": task[:100],
                "agent.type": type(agent).__name__
            })
            
            # Execute with timeout
            result = agent.run(task, timeout=30)
            
            # Track success metrics
            span.set_attribute("execution.success", True)
            span.set_attribute("execution.result_size", len(str(result)))
            
            return result
            
        except TimeoutError as e:
            span.record_exception(e)
            span.set_attribute("error.type", "timeout")
            return "Task timed out. Please try a simpler request."
            
        except Exception as e:
            span.record_exception(e)
            span.set_attribute("error.type", type(e).__name__)
            span.set_attribute("error.message", str(e))
            raise

from google.adk.deployment import VertexAIDeployment

# Deploy agent to Vertex AI
deployment = VertexAIDeployment(
    project_id="your-project-id",
    region="us-central1"
)

# Deploy your agent
deployment.deploy(
    agent=agent,
    name="my-adk-agent",
    version="1.0.0"
)

# The agent is now available as an API endpoint
endpoint = deployment.get_endpoint()
print(f"Agent deployed at: {endpoint}")

from google.adk.evaluation import Evaluator

# Create evaluator
evaluator = Evaluator(
    metrics=["accuracy", "latency", "cost"]
)

# Evaluate agent performance
test_cases = [
    "What is the capital of France?",
    "Explain quantum computing",
    "Write a haiku about AI"
]

results = evaluator.evaluate(
    agent=agent,
    test_cases=test_cases
)

print(f"Average accuracy: {results['accuracy']}")
print(f"Average latency: {results['latency']}ms")
print(f"Total cost: ${results['cost']}")