OpenAI Antworten API

ADK-Rust bietet einen dedizierten Client für OpenAIs Responses API (/v1/responses-Endpunkt) — den Nachfolger der Chat Completions API. Die Responses API ist die empfohlene Methode zur Verwendung der aktuellen GPT-5.6-Modelle einschließlich ihres vollständigen Spektrums an Reasoning-Aufwand.

Übersicht

┌─────────────────────────────────────────────────────────────────────┐
│                  OpenAI Responses API Client                        │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   Endpoint:  POST /v1/responses                                     │
│   Client:    OpenAIResponsesClient                                  │
│   Config:    OpenAIResponsesConfig                                  │
│   Feature:   openai                                                 │
│                                                                     │
│   Capabilities:                                                     │
│   • Streaming and non-streaming                                     │
│   • Reasoning summaries                                             │
│   • Tool / function calling                                         │
│   • Multi-turn via previous_response_id                             │
│   • Built-in tools (web search, file search, code interpreter)      │
│   • System instructions                                             │
│   • Model-aware sampling controls and max_output_tokens             │
│   • Automatic retry with exponential backoff                        │
│                                                                     │
│   vs Chat Completions (OpenAIClient):                               │
│   • Stateful conversations (server-side context)                    │
│   • Native reasoning summaries                                      │
│   • Built-in tool hosting                                           │
│   • Simpler multi-turn (no manual message history)                  │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Welchen Client wann verwenden

Verwenden Sie OpenAIResponsesClient, wenn Sie Reasoning-Modelle mit Zusammenfassungen und integrierten Tools benötigen oder die neuesten API von OpenAI verwenden möchten. Verwenden Sie OpenAIClient für Abwärtskompatibilität mit bestehenden Chat-Completions-Workflows.

---

Installation

[dependencies]
adk-rust = { version = "2.1.0", features = ["openai"] }
adk-tool = "2.1.0"

Oder direkt mit adk-model:

[dependencies]
adk-model = { version = "2.1.0", features = ["openai"] }

Legen Sie Ihren API-Schlüssel fest:

export OPENAI_API_KEY="sk-..."

---

Schnellstart

use adk_rust::prelude::*;
use adk_rust::session::{CreateRequest, SessionService};
use adk_rust::futures::StreamExt;
use adk_model::openai::{OpenAIResponsesClient, OpenAIResponsesConfig};
use std::collections::HashMap;
use std::sync::Arc;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("OPENAI_API_KEY")?;

    // 1. Create the Responses API client
    let config = OpenAIResponsesConfig::new(&api_key, "gpt-5.6-terra");
    let model = Arc::new(OpenAIResponsesClient::new(config)?);

    // 2. Build an agent
    let agent = Arc::new(
        LlmAgentBuilder::new("assistant")
            .instruction("You are a helpful assistant. Be concise.")
            .model(model)
            .build()?,
    );

    // 3. Create a session
    let sessions: Arc<dyn SessionService> = Arc::new(InMemorySessionService::new());
    sessions.create(CreateRequest {
        app_name: "my_app".into(),
        user_id: "user".into(),
        session_id: Some("s1".into()),
        state: HashMap::new(),
    }).await?;

    // 4. Run through the Runner
    let runner = Runner::builder()
        .app_name("my_app")
        .agent(agent)
        .session_service(sessions)
        .build()?;

    let message = Content::new("user").with_text("What is the capital of France?");
    let mut stream = runner.run(
        adk_rust::UserId::new("user")?,
        adk_rust::SessionId::new("s1")?,
        message,
    ).await?;

    while let Some(event) = stream.next().await {
        let event = event?;
        if let Some(content) = &event.llm_response.content {
            for part in &content.parts {
                if let Some(text) = part.text() {
                    print!("{text}");
                }
            }
        }
    }
    println!();
    Ok(())
}

---

Konfiguration

Grundlegende Konfiguration

use adk_model::openai::OpenAIResponsesConfig;

// Minimal — just API key and model
let config = OpenAIResponsesConfig::new("sk-...", "gpt-5.6-luna");

// With organization and project
let config = OpenAIResponsesConfig::new("sk-...", "gpt-5.6-terra")
    .with_organization("org-...")
    .with_project("proj-...");

// Custom base URL (for proxies or compatible APIs)
let config = OpenAIResponsesConfig::new("sk-...", "gpt-5.6-terra")
    .with_base_url("https://my-proxy.example.com/v1");

Reasoning-Modelle

Konfigurieren Sie für GPT-5.6-Reasoning-Modelle den Reasoning-Aufwand und die Zusammenfassung:

use adk_model::openai::{
    OpenAIReasoningEffort, OpenAIResponsesClient,
    OpenAIResponsesConfig, ReasoningSummary,
};

let config = OpenAIResponsesConfig::new("sk-...", "gpt-5.6-terra")
    .with_reasoning_summary(ReasoningSummary::Detailed);

let model = OpenAIResponsesClient::new_with_reasoning_effort(
    config,
    OpenAIReasoningEffort::Max,
)?;

GPT-5.6 unterstützt None, Low, Medium, High, XHigh und Max über die Responses API. Chat Completions unterstützt bis zu XHigh.

Zusammenfassungen der Schlussfolgerungen erscheinen als Part::Thinking im Antwortstream, sodass Sie den Denkprozess des Modells für Benutzer anzeigen können.

Wiederholungs-Konfiguration

use adk_model::retry::RetryConfig;

let client = OpenAIResponsesClient::new(config)?
    .with_retry_config(RetryConfig {
        max_retries: 3,
        ..Default::default()
    });

Wiederholungsversuche erfolgen automatisch bei Ratenbegrenzungen (429), Serverfehlern (500/502/503/504) und Netzwerkfehlern.

---

Verfügbare Modelle

---

Funktionen

Tool-Aufrufe

Funktionstools funktionieren genauso wie bei OpenAIClient — definieren Sie Tools am Agenten, und der Runner übernimmt die Tool-Aufrufschleife:

use adk_rust::prelude::*;
use adk_model::openai::{OpenAIResponsesClient, OpenAIResponsesConfig};
use adk_tool::FunctionTool;
use std::sync::Arc;

async fn get_weather(
    _ctx: Arc<dyn ToolContext>,
    args: serde_json::Value,
) -> Result<serde_json::Value> {
    let city = args["city"].as_str().unwrap_or("unknown");
    Ok(serde_json::json!({
        "city": city,
        "temperature_f": 72,
        "conditions": "Sunny"
    }))
}

let weather_tool = FunctionTool::new(
    "get_weather",
    "Get current weather for a city. Requires a 'city' string parameter.",
    get_weather,
);

let config = OpenAIResponsesConfig::new(&api_key, "gpt-5.6-terra");
let model = Arc::new(OpenAIResponsesClient::new(config)?);

let agent = LlmAgentBuilder::new("weather_agent")
    .instruction("Use the get_weather tool to answer weather questions.")
    .model(model)
    .tool(Arc::new(weather_tool))
    .build()?;

Mehrfachinteraktionen

Der Runner verwaltet den Gesprächsverlauf automatisch über Sessions. Der Kontext jedes Durchlaufs bleibt erhalten:

// Turn 1
let msg1 = Content::new("user").with_text("My name is Alice.");
let mut stream = runner.run(uid.clone(), sid.clone(), msg1).await?;
// ... consume stream ...

// Turn 2 — the model remembers the previous turn
let msg2 = Content::new("user").with_text("What is my name?");
let mut stream = runner.run(uid.clone(), sid.clone(), msg2).await?;
// Response: "Your name is Alice."

Anfragebezogene Überschreibung der Reasoning-Einstellungen

Überschreiben Sie die Reasoning-Einstellungen pro Anfrage mithilfe der LlmRequest-Erweiterungen:

use adk_rust::prelude::*;

let agent = LlmAgentBuilder::new("flexible_reasoner")
    .model(model)
    .generate_content_config(GenerateContentConfig {
        extensions: {
            let mut ext = std::collections::HashMap::new();
            ext.insert("openai".to_string(), serde_json::json!({
                "reasoning": {
                    "effort": "high",
                    "summary": "detailed"
                }
            }));
            ext
        },
        ..Default::default()
    })
    .build()?;

Integrierte Tools

Der Responses API unterstützt von OpenAI bereitgestellte Tools. Verwenden Sie bevorzugt die typisierten Wrapper aus adk-tool:

use adk_tool::OpenAIWebSearchTool;
use std::sync::Arc;

let agent = LlmAgentBuilder::new("researcher")
    .model(model)
    .tool(Arc::new(OpenAIWebSearchTool::new().preview()))
    .build()?;

Zu den verfügbaren Wrappern gehören OpenAIWebSearchTool, OpenAIFileSearchTool, OpenAICodeInterpreterTool, OpenAIImageGenerationTool, OpenAIComputerUseTool, OpenAIMcpTool, OpenAILocalShellTool, OpenAIShellTool und OpenAIApplyPatchTool.

ID der vorherigen Antwort

Für den serverseitigen Gesprächszustand (unter Umgehung des lokalen Session-Verlaufs) übergeben Sie previous_response_id:

let agent = LlmAgentBuilder::new("stateful")
    .model(model)
    .generate_content_config(GenerateContentConfig {
        extensions: {
            let mut ext = std::collections::HashMap::new();
            ext.insert("openai".to_string(), serde_json::json!({
                "previous_response_id": "resp_abc123"
            }));
            ext
        },
        ..Default::default()
    })
    .build()?;

---

Streaming-Verhalten

Der Responses API-Client streamt Text- und Reasoning-Deltas in Echtzeit:

• Text-Deltas treffen als Part::Text mit partial: true ein
• Reasoning-Zusammenfassungs-Deltas treffen als Part::Thinking mit partial: true ein
• Funktionsaufrufe werden aus dem finalen ResponseCompleted-Ereignis mit den korrekten Namen und Argumenten ausgegeben
• Das abschließende Ereignis enthält turn_complete: true mit Nutzungsmetadaten und dem Beendigungsgrund

Das bedeutet, dass Sie sehen, wie der Text Token für Token erscheint, während das Modell ihn generiert, und dass Funktionsaufrufe als vollständige, zur Ausführung bereite Objekte eintreffen.

---

Provider-Metadaten

Jede Antwort enthält Provider-Metadaten mit dem response_id:

if let Some(meta) = &response.provider_metadata {
    let response_id = meta["openai"]["response_id"].as_str();
    // Use for previous_response_id, logging, debugging
}

Zusätzliche Metadaten können Folgendes enthalten:

• encrypted_content — von Reasoning-Modellen (zur Erhaltung des Kontexts)
• built_in_tool_outputs — Ergebnisse aus Websuche, Dateisuche und Code-Interpreter

---

Fehlerbehandlung

Fehler werden geeigneten Kategorien entsprechend auf strukturierte AdkError abgebildet:

match runner.run(uid, sid, message).await {
    Ok(stream) => { /* process stream */ }
    Err(e) if e.is_retryable() => { /* retry logic */ }
    Err(e) if e.is_unauthorized() => { /* check API key */ }
    Err(e) => { /* handle other errors */ }
}

---

Hintergrundmodus und Abbruch

Für lang andauernde Anfragen senden Sie sie mit background: true und fragen Sie den Abschluss regelmäßig ab:

use adk_model::openai::{OpenAIResponsesClient, OpenAIResponsesConfig};

let client = OpenAIResponsesClient::new(config)?;

// Submit with background: true via extensions
let mut gen_config = GenerateContentConfig::default();
gen_config.extensions.insert("openai".into(), serde_json::json!({ "background": true }));

// ... send request, extract response_id from provider_metadata ...

// Poll until terminal status
let response = client.poll_response("resp_abc123").await?;
// Check provider_metadata["openai"]["status"]: "completed", "in_progress", "failed", "cancelled"

// Cancel a running background response
let cancelled = client.cancel_response("resp_abc123").await?;

Deep-Research-Modelle (o3-deep-research, o4-mini-deep-research) aktivieren den Hintergrundmodus automatisch, ohne dass background: true explizit angegeben werden muss.

---

Beispiel

Ein vollständiges Beispiel mit 7 Szenarien ist unter examples/openai_responses/ verfügbar:

export OPENAI_API_KEY=sk-...
cargo run --manifest-path examples/openai_responses/Cargo.toml

Abgedeckte Szenarien:

1. Einfacher Chat ohne Streaming
2. Einfacher Chat mit Streaming
3. Reasoning-Modell mit Zusammenfassung (Kompatibilitätspfad für o4-mini)
4. Tool-Aufrufe mit Funktionstools
5. Mehrere Gesprächsrunden
6. Systemanweisungen
7. Temperatur- und Generierungskonfiguration (Kompatibilitätspfad für gpt-4.1-nano)

Weitere Beispiele

Sechs eigenständige Beispiel-Crates veranschaulichen spezifische Responses-API-Funktionen:

---

Verwandte Themen

• Cloud-Modellanbieter — Alle unterstützten LLM-Anbieter
• Ollama (lokal) — Modelle lokal ausführen
• LlmAgent — Modelle mit Agents verwenden
• Funktionstools — Tools zu Agents hinzufügen

---

Zurück: ← Cloud-Anbieter | Weiter: Ollama (lokal) →