Google ADK Integration

Add payment capabilities to Gemini agents using Google's Agent Development Kit with Sardis FunctionTool instances.

Installation

pip install sardis-adk

The ADK integration provides Sardis tools as FunctionTool instances compatible with Google's Agent Development Kit.

Quick Start

SardisToolkit

Initialize the toolkit and get ADK-compatible FunctionTool instances.

from google import genai
from sardis_adk import SardisToolkit

# Initialize the toolkit
toolkit = SardisToolkit(
    api_key="sk_live_...",
    agent_id="agent_abc123"
)

# Get all Sardis tools as FunctionTool instances
tools = toolkit.get_tools()

# Create Gemini client with tools
client = genai.Client(api_key="your_google_api_key")
response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents="Pay $20 to OpenAI for API credits",
    config={"tools": tools}
)

print(response.text)

Available Tools

The toolkit provides 5 tools as plain Python functions wrapped in FunctionTool:

sardis_pay

Execute a payment to a merchant.

from sardis_adk import sardis_pay, configure

# Configure module-level state
configure(api_key="sk_live_...", agent_id="agent_abc123")

# Call directly
result = sardis_pay(
    merchant="api.openai.com",
    amount="20.00",
    token="USDC",
    chain="base",
    purpose="API credits"
)

# Returns
{
    "payment_id": "pay_xyz789",
    "status": "completed",
    "tx_hash": "0x1234...",
    "amount": "20.00",
    "token": "USDC"
}

sardis_check_balance

Get wallet balances across all chains.

from sardis_adk import sardis_check_balance

result = sardis_check_balance(
    chain="base",  # Optional
    token="USDC"   # Optional
)

# Returns
{
    "balances": [
        {
            "chain": "base",
            "token": "USDC",
            "balance": "1250.00",
            "usd_value": "1250.00"
        }
    ],
    "total_usd": "1250.00"
}

sardis_check_policy

Validate if a payment would be allowed.

from sardis_adk import sardis_check_policy

result = sardis_check_policy(
    merchant="aws.amazon.com",
    amount="500.00",
    purpose="EC2 hosting"
)

# Returns
{
    "allowed": false,
    "reason": "Daily limit of $100 would be exceeded"
}

sardis_set_policy

Update spending policies.

from sardis_adk import sardis_set_policy

result = sardis_set_policy(
    policy="Allow up to $100 per day for OpenAI, max $20 per transaction"
)

# Returns
{
    "policy_id": "pol_abc123",
    "status": "active",
    "rules": [...]
}

sardis_list_transactions

Query transaction history.

from sardis_adk import sardis_list_transactions

result = sardis_list_transactions(
    merchant="api.openai.com",  # Optional
    start_date="2026-01-01",    # Optional
    end_date="2026-01-31",      # Optional
    limit=10                     # Optional
)

# Returns
{
    "transactions": [...],
    "total_count": 42
}

Module Configuration

Use configure() to set module-level state for direct function calls.

from sardis_adk import configure, sardis_pay, sardis_check_balance

# Configure once at startup
configure(
    api_key="sk_live_...",
    agent_id="agent_abc123",
    base_url="https://api.sardis.sh"  # Optional
)

# Now all functions use the configured state
balance = sardis_check_balance()
payment = sardis_pay(
    merchant="api.openai.com",
    amount="20.00",
    token="USDC",
    chain="base",
    purpose="API credits"
)

Example: Gemini Agent with Payments

Complete example of a Gemini agent with payment capabilities.

import os
from google import genai
from sardis_adk import SardisToolkit

# Initialize
toolkit = SardisToolkit(
    api_key=os.environ["SARDIS_API_KEY"],
    agent_id="agent_gemini_payments"
)

client = genai.Client(api_key=os.environ["GOOGLE_API_KEY"])

# Create agent with tools
response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents="""
    You are a financial assistant. You can:
    1. Check balances
    2. Make payments
    3. Review spending policies

    User request: Check my balance, then pay $25 to Anthropic for Claude API.
    """,
    config={
        "tools": toolkit.get_tools(),
        "temperature": 0
    }
)

# Handle function calls in the response
for part in response.candidates[0].content.parts:
    if hasattr(part, 'function_call'):
        fn_call = part.function_call
        print(f"Calling: {fn_call.name}")
        print(f"Args: {fn_call.args}")
    else:
        print(response.text)

Advanced: Manual Function Execution

For custom agent loops, you can manually execute function calls.

from google import genai
from google.genai.types import FunctionResponse, Part
from sardis_adk import SardisToolkit, configure

# Configure
configure(api_key="sk_live_...", agent_id="agent_abc123")

toolkit = SardisToolkit()
client = genai.Client(api_key="your_google_api_key")

user_query = "Pay $30 to OpenAI"

# Initial request
response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=user_query,
    config={"tools": toolkit.get_tools()}
)

# Agent loop
while True:
    part = response.candidates[0].content.parts[0]

    if hasattr(part, 'function_call'):
        fn_call = part.function_call

        # Execute the function
        fn_map = toolkit.get_function_map()
        result = fn_map[fn_call.name](**fn_call.args)

        # Send result back to model
        response = client.models.generate_content(
            model="gemini-2.0-flash",
            contents=[
                user_query,
                Part.from_function_response(
                    FunctionResponse(
                        name=fn_call.name,
                        response=result
                    )
                )
            ],
            config={"tools": toolkit.get_tools()}
        )
    else:
        print(response.text)
        break

Best Practices

Use configure() at application startup to set credentials once
Set temperature=0 for financial agents to ensure deterministic behavior
Always validate function call results before sending back to the model
Use sardis_check_policy before sardis_pay in multi-step workflows
Handle function execution errors gracefully in your agent loop
Use get_function_map() for manual function dispatch in custom loops

Google ADK Integration

On this page