Smart routing for agent loops.
One model per step. One API.

# The OpenAI Python SDK is the lowest-common-denominator client for
# agent loops. Point base_url at GammaInfra and the same code routes
# across every major provider with per-step header controls.
from openai import OpenAI

client = OpenAI(
  base_url="https://api.gammainfra.com/v1",
  api_key="sk-gammainfra-...",
)

# Planner step: bias toward reasoning, give it a 30s budget.
plan = client.chat.completions.create(
  model="gammainfra/auto",
  messages=[{"role": "user", "content": "Plan the steps to refactor this module..."}],
  extra_headers={
    "X-GammaInfra-Cost-Quality": "0.2",        # quality-biased
    "X-GammaInfra-Max-Latency-Ms": "30000",    # cancel if upstream tails
  },
)

# Extractor step in the same loop: bias toward cheap.
extract = client.chat.completions.create(
  model="gammainfra/auto",
  messages=[{"role": "user", "content": "Extract function names as JSON..."}],
  extra_headers={"X-GammaInfra-Cost-Quality": "0.8"},   # cost-biased
)

# Every response carries the cost split + which model served you:
#   X-GammaInfra-Endpoint:           deepseek/deepseek-v4-pro
#   X-GammaInfra-Input-Cost-USD:     0.000034
#   X-GammaInfra-Output-Cost-USD:    0.000128
#   X-GammaInfra-Fallback-Chain:     deepseek-v4-pro,gpt-5.4,claude-opus-4-6

# LangGraph nodes accept any ChatOpenAI-compatible client. Point at
# GammaInfra and per-node routing comes from headers, not model swaps.
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, MessagesState

planner = ChatOpenAI(
  base_url="https://api.gammainfra.com/v1",
  api_key="sk-gammainfra-...",
  model="gammainfra/auto",
  default_headers={"X-GammaInfra-Preference": "quality"},
)

extractor = ChatOpenAI(
  base_url="https://api.gammainfra.com/v1",
  api_key="sk-gammainfra-...",
  model="gammainfra/auto",
  default_headers={
    "X-GammaInfra-Preference": "cost",
    "X-GammaInfra-Max-Latency-Ms": "5000",
  },
)

def plan_node(state: MessagesState):
  return {"messages": [planner.invoke(state["messages"])]}

def extract_node(state: MessagesState):
  return {"messages": [extractor.invoke(state["messages"])]}

graph = StateGraph(MessagesState)
graph.add_node("plan", plan_node)
graph.add_node("extract", extract_node)
graph.add_edge("plan", "extract")

# Different nodes route to different models without ever importing
# a second SDK. Header changes; same OpenAI shape underneath.

# OpenAI Agents SDK wraps a custom OpenAI client in OpenAIChatCompletionsModel.
# Per-call routing goes through ModelSettings(extra_headers=...) on a RunConfig.
from openai import AsyncOpenAI
from agents import Agent, Runner, OpenAIChatCompletionsModel
from agents.model_settings import ModelSettings
from agents.run import RunConfig

client = AsyncOpenAI(
  base_url="https://api.gammainfra.com/v1",
  api_key="sk-gammainfra-...",
)

agent = Agent(
  name="research_agent",
  instructions="Plan, search, summarize.",
  model=OpenAIChatCompletionsModel(
    model="gammainfra/auto",
    openai_client=client,
  ),
)

# Per-run constraint: never spend more than 8 seconds on one upstream call.
run_config = RunConfig(
  model_settings=ModelSettings(
    extra_headers={"X-GammaInfra-Max-Latency-Ms": "8000"},
  ),
)

result = await Runner.run(
  agent,
  input="Find the three biggest changes in HTTP/3 vs HTTP/2.",
  run_config=run_config,
)

# The agent step gets routed to the best tool-capable model
# in the moment. Tool-call IDs are normalized to call_* on the way out,
# so the OpenAI SDK's assertions hold across providers.

# AutoGen's OpenAIChatCompletionClient takes base_url + default_headers.
# Wire one client per persona, then assemble agents on top of those clients.
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.agents import AssistantAgent

# Reasoning persona — quality-biased.
planner_model = OpenAIChatCompletionClient(
  model="gammainfra/auto",
  base_url="https://api.gammainfra.com/v1",
  api_key="sk-gammainfra-...",
  default_headers={
    "X-GammaInfra-Cost-Quality": "0.2",
    "X-GammaInfra-Max-Latency-Ms": "30000",
  },
)

# Extraction persona — cost-biased, tighter latency budget.
extractor_model = OpenAIChatCompletionClient(
  model="gammainfra/auto",
  base_url="https://api.gammainfra.com/v1",
  api_key="sk-gammainfra-...",
  default_headers={
    "X-GammaInfra-Cost-Quality": "0.8",
    "X-GammaInfra-Max-Latency-Ms": "5000",
  },
)

planner = AssistantAgent("planner", model_client=planner_model)
extractor = AssistantAgent("extractor", model_client=extractor_model)

# Different agents land on different models without ever swapping SDKs.
# Each client carries its own per-step headers; GammaInfra routes accordingly.