SDK Configuration

from agentfield import AIConfig

# Simple configuration
config = AIConfig(
    model="gpt-4o",
    temperature=0.7,
    max_tokens=2000
)

# Use with agent
app = Agent(node_id="my_agent", ai_config=config)

from agentfield import AIConfig

# Multimodal configuration
config = AIConfig(
    model="gpt-4o",
    vision_model="dall-e-3",
    audio_model="tts-1-hd",
    image_quality="high",
    audio_format="mp3"
)

# Generate images
response = await app.ai_with_vision(
    "A serene mountain landscape",
    size="1792x1024",
    quality="hd"
)

from agentfield import AIConfig

# Robust rate limit handling
config = AIConfig(
    model="gpt-4o",
    enable_rate_limit_retry=True,
    rate_limit_max_retries=20,
    rate_limit_base_delay=1.0,
    rate_limit_max_delay=300.0,
    retry_attempts=3
)

from agentfield import AIConfig

# Load from environment variables
# OPENAI_API_KEY, ANTHROPIC_API_KEY, etc.
config = AIConfig.from_env()

# Override specific settings
config = AIConfig.from_env(
    model="gpt-4o",
    temperature=0.8
)

from agentfield import MemoryConfig

# Session-scoped memory (cleared after session)
config = MemoryConfig(
    memory_retention="session",
    cache_results=True
)

app = Agent(node_id="session_agent", memory_config=config)

@app.reasoner
async def chat(message: str, user_id: str) -> str:
    # Memory cleared when session ends
    history = await app.memory.get(f"user_{user_id}_chat", default=[])
    history.append(message)
    await app.memory.set(f"user_{user_id}_chat", history)

    return await app.ai(
        system=f"Chat history: {history[-5:]}",
        user=message
    )

from agentfield import MemoryConfig

# Persistent memory (never cleared)
config = MemoryConfig(
    memory_retention="persistent",
    cache_results=True
)

app = Agent(node_id="persistent_agent", memory_config=config)

@app.reasoner
async def learn_preference(user_id: str, preference: dict) -> str:
    # Persists across all sessions
    prefs = await app.memory.get(f"user_{user_id}_prefs", default={})
    prefs.update(preference)
    await app.memory.set(f"user_{user_id}_prefs", prefs)

    return f"Learned preference: {preference}"

from agentfield import MemoryConfig

# Auto-inject memory into AI calls
config = MemoryConfig(
    auto_inject=["user_context", "conversation_history"],
    memory_retention="persistent"
)

app = Agent(node_id="context_agent", memory_config=config)

# Memory automatically included in AI context
@app.reasoner
async def personalized_response(message: str) -> str:
    # user_context and conversation_history
    # automatically injected into AI call
    return await app.ai(user=message)

from agentfield.async_config import AsyncConfig

# Enable async execution
config = AsyncConfig(
    enable_async_execution=True,
    max_execution_timeout=3600,
    fallback_to_sync=True
)

app = Agent(node_id="async_agent", async_config=config)

# Long-running tasks automatically use async execution
result = await app.call(
    "research_agent.deep_analysis",
    topic="quantum computing"
)

from agentfield.async_config import AsyncConfig

# Aggressive polling for fast response
config = AsyncConfig(
    initial_poll_interval=0.01,  # 10ms
    fast_poll_interval=0.05,     # 50ms
    medium_poll_interval=0.2,    # 200ms
    slow_poll_interval=1.0,      # 1s
    max_poll_interval=2.0        # 2s max
)

app = Agent(node_id="fast_agent", async_config=config)

from agentfield.async_config import AsyncConfig

# Load from environment variables
# BRAIN_ASYNC_MAX_EXECUTION_TIMEOUT=1800
# BRAIN_ASYNC_BATCH_SIZE=50
config = AsyncConfig.from_environment()

app = Agent(node_id="env_agent", async_config=config)