Add gemini example using litellm

Author: danielmillerp

examples/tutorials/10_async/10_temporal/100_gemini_litellm/.dockerignore

@@ -0,0 +1,43 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Environments
+.env**
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Git
+.git
+.gitignore
+
+# Misc
+.DS_Store

examples/tutorials/10_async/10_temporal/100_gemini_litellm/Dockerfile

@@ -0,0 +1,62 @@
+# syntax=docker/dockerfile:1.3
+FROM python:3.12-slim
+COPY --from=ghcr.io/astral-sh/uv:0.6.4 /uv /uvx /bin/
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    htop \
+    vim \
+    curl \
+    tar \
+    python3-dev \
+    postgresql-client \
+    build-essential \
+    libpq-dev \
+    gcc \
+    cmake \
+    netcat-openbsd \
+    nodejs \
+    npm \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/**
+
+# Install tctl (Temporal CLI)
+RUN curl -L https://github.com/temporalio/tctl/releases/download/v1.18.1/tctl_1.18.1_linux_arm64.tar.gz -o /tmp/tctl.tar.gz && \
+    tar -xzf /tmp/tctl.tar.gz -C /usr/local/bin && \
+    chmod +x /usr/local/bin/tctl && \
+    rm /tmp/tctl.tar.gz
+
+RUN uv pip install --system --upgrade pip setuptools wheel
+
+ENV UV_HTTP_TIMEOUT=1000
+
+# Copy pyproject.toml and README.md to install dependencies
+COPY 10_async/10_temporal/100_gemini_litellm/pyproject.toml /app/100_gemini_litellm/pyproject.toml
+COPY 10_async/10_temporal/100_gemini_litellm/README.md /app/100_gemini_litellm/README.md
+
+WORKDIR /app/100_gemini_litellm
+
+# Copy the project code
+COPY 10_async/10_temporal/100_gemini_litellm/project /app/100_gemini_litellm/project
+
+# Copy the test files
+COPY 10_async/10_temporal/100_gemini_litellm/tests /app/100_gemini_litellm/tests
+
+# Copy shared test utilities
+COPY test_utils /app/test_utils
+
+# Install the required Python packages with dev dependencies
+RUN uv pip install --system .[dev]
+
+WORKDIR /app/100_gemini_litellm
+
+ENV PYTHONPATH=/app
+
+# Set test environment variables
+ENV AGENT_NAME=at100-gemini-litellm
+
+# Run the ACP server using uvicorn
+CMD ["uvicorn", "project.acp:acp", "--host", "0.0.0.0", "--port", "8000"]
+
+# When we deploy the worker, we will replace the CMD with the following
+# CMD ["python", "-m", "run_worker"]

examples/tutorials/10_async/10_temporal/100_gemini_litellm/README.md

@@ -0,0 +1,130 @@
+# [Temporal] Using Alternative Models with LiteLLM (Gemini)
+
+**Part of the [OpenAI SDK + Temporal integration series](../README.md)**
+
+## What You'll Learn
+
+This tutorial demonstrates how to use Google's Gemini models (or any other LLM provider) with the OpenAI Agents SDK through LiteLLM. The key insight is that LiteLLM provides a unified interface, allowing you to swap models without changing your agent code structure.
+
+**Key insight:** You can use the same OpenAI Agents SDK patterns with any LLM provider supported by LiteLLM - Gemini, Anthropic Claude, Mistral, and many more.
+
+## Prerequisites
+- Development environment set up (see [main repo README](https://github.com/scaleapi/scale-agentex))
+- Backend services running: `make dev` from repository root (includes Temporal)
+- Temporal UI available at http://localhost:8233
+- **Google Gemini API key** (see setup below)
+- Understanding of OpenAI Agents SDK basics (see [060_open_ai_agents_sdk_hello_world](../060_open_ai_agents_sdk_hello_world/))
+
+## Setup
+
+### 1. Get a Gemini API Key
+
+1. Go to [Google AI Studio](https://aistudio.google.com/apikey)
+2. Create a new API key
+3. Copy the key for the next step
+
+### 2. Configure the API Key
+
+Add to your environment or `manifest.yaml`:
+
+**Option A: Environment variable**
+```bash
+export GEMINI_API_KEY="your-gemini-api-key-here"
+```
+
+**Option B: In manifest.yaml**
+```yaml
+agent:
+  env:
+    GEMINI_API_KEY: "your-gemini-api-key-here"
+```
+
+### 3. Install LiteLLM Dependency
+
+The `pyproject.toml` already includes `litellm>=1.52.0`. When you run the agent, dependencies are installed automatically.
+
+## Quick Start
+
+```bash
+cd examples/tutorials/10_async/10_temporal/100_gemini_litellm
+uv run agentex agents run --manifest manifest.yaml
+```
+
+**Monitor:** Open Temporal UI at http://localhost:8233 to see workflow execution.
+
+## Key Code Changes
+
+The main difference from OpenAI examples is using `LitellmModel`:
+
+```python
+from agents.extensions.models.litellm_model import LitellmModel
+
+# Create a LiteLLM model pointing to Gemini
+gemini_model = LitellmModel(model="gemini/gemini-2.0-flash")
+
+agent = Agent(
+    name="Gemini Assistant",
+    instructions="You are a helpful assistant powered by Gemini.",
+    model=gemini_model,  # Use the LiteLLM model instead of default
+)
+
+# Run works exactly the same way
+result = await Runner.run(agent, user_messages)
+```
+
+## Supported Models
+
+LiteLLM supports many providers. Just change the model string:
+
+| Provider | Model String Example |
+|----------|---------------------|
+| Google Gemini | `gemini/gemini-2.0-flash`, `gemini/gemini-1.5-pro` |
+| Anthropic | `anthropic/claude-3-sonnet-20240229` |
+| Mistral | `mistral/mistral-large-latest` |
+| Cohere | `cohere/command-r-plus` |
+| AWS Bedrock | `bedrock/anthropic.claude-3-sonnet` |
+
+See [LiteLLM Providers](https://docs.litellm.ai/docs/providers) for the full list.
+
+## Why LiteLLM?
+
+**Model Flexibility:** Switch between providers without code changes - just update the model string.
+
+**Unified Interface:** Same OpenAI Agents SDK patterns work with any provider.
+
+**Cost Optimization:** Easily compare costs across providers by switching models.
+
+**Fallback Support:** LiteLLM supports automatic fallbacks if a provider is unavailable.
+
+## Architecture Notes
+
+The Temporal integration remains identical:
+- Workflows are durable and survive restarts
+- LLM calls are wrapped as activities automatically
+- Full observability in Temporal UI
+- Automatic retries on failures
+
+The only change is the model provider - everything else works the same.
+
+## When to Use
+
+- Want to use non-OpenAI models with OpenAI Agents SDK
+- Need to compare model performance across providers
+- Building multi-model systems with fallbacks
+- Cost optimization across different providers
+- Regulatory requirements for specific model providers
+
+## Troubleshooting
+
+**"GEMINI_API_KEY environment variable is not set"**
+- Ensure you've exported the API key or added it to manifest.yaml
+
+**"Model not found" errors**
+- Check the model string format matches LiteLLM's expected format
+- See [LiteLLM Providers](https://docs.litellm.ai/docs/providers) for correct model names
+
+**Rate limiting errors**
+- Gemini has different rate limits than OpenAI
+- Consider adding retry logic or using LiteLLM's built-in retry support
+
+**Previous:** [090_claude_agents_sdk_mvp](../090_claude_agents_sdk_mvp/) - Claude SDK integration

examples/tutorials/10_async/10_temporal/100_gemini_litellm/manifest.yaml

@@ -0,0 +1,140 @@
+# Agent Manifest Configuration
+# ---------------------------
+# This file defines how your agent should be built and deployed.
+
+# Build Configuration
+# ------------------
+# The build config defines what gets packaged into your agent's Docker image.
+# This same configuration is used whether building locally or remotely.
+#
+# When building:
+# 1. All files from include_paths are collected into a build context
+# 2. The context is filtered by dockerignore rules
+# 3. The Dockerfile uses this context to build your agent's image
+# 4. The image is pushed to a registry and used to run your agent
+build:
+  context:
+    # Root directory for the build context
+    root: ../../../  # Up to tutorials level to include test_utils
+
+    # Paths to include in the Docker build context
+    # Must include:
+    # - Your agent's directory (your custom agent code)
+    # These paths are collected and sent to the Docker daemon for building
+    include_paths:
+      - 10_async/10_temporal/100_gemini_litellm
+      - test_utils
+
+    # Path to your agent's Dockerfile
+    # This defines how your agent's image is built from the context
+    # Relative to the root directory
+    dockerfile: 10_async/10_temporal/100_gemini_litellm/Dockerfile
+
+    # Path to your agent's .dockerignore
+    # Filters unnecessary files from the build context
+    # Helps keep build context small and builds fast
+    dockerignore: 10_async/10_temporal/100_gemini_litellm/.dockerignore
+
+
+# Local Development Configuration
+# -----------------------------
+# Only used when running the agent locally
+local_development:
+  agent:
+    port: 8000  # Port where your local ACP server is running
+    host_address: host.docker.internal  # Host address for Docker networking (host.docker.internal for Docker, localhost for direct)
+
+  # File paths for local development (relative to this manifest.yaml)
+  paths:
+    # Path to ACP server file
+    # Examples:
+    #   project/acp.py          (standard)
+    #   src/server.py           (custom structure)
+    #   ../shared/acp.py        (shared across projects)
+    #   /absolute/path/acp.py   (absolute path)
+    acp: project/acp.py
+
+    # Path to temporal worker file
+    # Examples:
+    #   project/run_worker.py   (standard)
+    #   workers/temporal.py     (custom structure)
+    #   ../shared/worker.py     (shared across projects)
+    worker: project/run_worker.py
+
+
+# Agent Configuration
+# -----------------
+agent:
+  # Type of agent - either sync or async
+  acp_type: async
+
+  # Unique name for your agent
+  # Used for task routing and monitoring
+  name: at100-gemini-litellm
+
+  # Description of what your agent does
+  # Helps with documentation and discovery
+  description: An AgentEx agent using Gemini via LiteLLM
+
+  # Temporal workflow configuration
+  # This enables your agent to run as a Temporal workflow for long-running tasks
+  temporal:
+    enabled: true
+    workflows:
+      # Name of the workflow class
+      # Must match the @workflow.defn name in your workflow.py
+      - name: at100-gemini-litellm
+
+        # Queue name for task distribution
+        # Used by Temporal to route tasks to your agent
+        # Convention: <agent_name>_task_queue
+        queue_name: at100_gemini_litellm_queue
+
+  # Optional: Credentials mapping
+  # Maps Kubernetes secrets to environment variables
+  # Common credentials include:
+  credentials:
+    - env_var_name: REDIS_URL
+      secret_name: redis-url-secret
+      secret_key: url
+    # - env_var_name: GEMINI_API_KEY
+    #   secret_name: gemini-api-key
+    #   secret_key: api-key
+
+  # Optional: Set Environment variables for running your agent locally as well
+  # as for deployment later on
+  env:
+    # Set your Gemini API key here or in your environment
+    # GEMINI_API_KEY: "<YOUR_GEMINI_API_KEY_HERE>"
+
+
+# Deployment Configuration
+# -----------------------
+# Configuration for deploying your agent to Kubernetes clusters
+deployment:
+  # Container image configuration
+  image:
+    repository: "" # Update with your container registry
+    tag: "latest"  # Default tag, should be versioned in production
+
+  imagePullSecrets:
+    - name: my-registry-secret  # Update with your image pull secret name
+
+  # Global deployment settings that apply to all clusters
+  # These can be overridden using --override-file with custom configuration files
+  global:
+    agent:
+      name: "at100-gemini-litellm"
+      description: "An AgentEx agent using Gemini via LiteLLM"
+
+    # Default replica count
+    replicaCount: 1
+
+    # Default resource requirements
+    resources:
+      requests:
+        cpu: "500m"
+        memory: "1Gi"
+      limits:
+        cpu: "1000m"
+        memory: "2Gi"

examples/tutorials/10_async/10_temporal/100_gemini_litellm/project/__init__.py

@@ -0,0 +1 @@
+# Gemini LiteLLM Tutorial