OpenAI प्रतिक्रियाएँ API

ADK-Rust, OpenAI के Responses API (/v1/responses endpoint) के लिए एक समर्पित क्लाइंट प्रदान करता है — यह Chat Completions API का उत्तराधिकारी है। Responses API वर्तमान GPT-5.6 मॉडल का उपयोग करने का अनुशंसित तरीका है, जिसमें उनकी reasoning-effort की पूरी सीमा भी शामिल है।

अवलोकन

┌─────────────────────────────────────────────────────────────────────┐
│                  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)                  │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

किस क्लाइंट का उपयोग कब करें

जब आपको सारांश, अंतर्निहित टूल वाले रीजनिंग मॉडल की आवश्यकता हो या OpenAI के नवीनतम API का उपयोग करना हो, तो OpenAIResponsesClient का उपयोग करें। मौजूदा Chat Completions वर्कफ़्लो के साथ पिछली संगतता के लिए OpenAIClient का उपयोग करें।

---

इंस्टॉलेशन

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

या सीधे adk-model के साथ:

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

अपनी API कुंजी सेट करें:

export OPENAI_API_KEY="sk-..."

---

त्वरित शुरुआत

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(())
}

---

कॉन्फ़िगरेशन

बुनियादी कॉन्फ़िगरेशन

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");

रीजनिंग मॉडल

GPT-5.6 रीजनिंग मॉडल के लिए, रीजनिंग प्रयास और सारांश कॉन्फ़िगर करें:

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, Responses API के माध्यम से None, Low, Medium, High, XHigh और Max का समर्थन करता है। Chat Completions अधिकतम XHigh तक का समर्थन करता है।

रीज़निंग सारांश प्रतिक्रिया स्ट्रीम में Part::Thinking के रूप में दिखाई देते हैं, जिससे आप उपयोगकर्ताओं को मॉडल की विचार प्रक्रिया दिखा सकते हैं।

पुनः प्रयास कॉन्फ़िगरेशन

use adk_model::retry::RetryConfig;

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

दर सीमा (429), सर्वर त्रुटियों (500/502/503/504) और नेटवर्क विफलताओं के लिए पुनः प्रयास स्वचालित होते हैं।

---

उपलब्ध मॉडल

---

सुविधाएँ

टूल कॉलिंग

फ़ंक्शन टूल OpenAIClient की तरह ही काम करते हैं — एजेंट पर टूल परिभाषित करें और रनर टूल कॉल लूप को संभालता है:

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()?;

मल्टी-टर्न वार्तालाप

रनर सेशनों के माध्यम से वार्तालाप इतिहास को स्वचालित रूप से प्रबंधित करता है। प्रत्येक टर्न का संदर्भ सुरक्षित रखा जाता है:

// 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."

प्रति-रिक्वेस्ट रीजनिंग ओवरराइड

LlmRequest एक्सटेंशन का उपयोग करके प्रत्येक रिक्वेस्ट के लिए रीजनिंग सेटिंग्स को ओवरराइड करें:

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()?;

बिल्ट-इन टूल

Responses API OpenAI-होस्टेड टूल का समर्थन करता है। adk-tool के टाइप किए गए रैपर को प्राथमिकता दें:

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

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

उपलब्ध रैपर में OpenAIWebSearchTool, OpenAIFileSearchTool, OpenAICodeInterpreterTool, OpenAIImageGenerationTool, OpenAIComputerUseTool, OpenAIMcpTool, OpenAILocalShellTool, OpenAIShellTool और OpenAIApplyPatchTool शामिल हैं।

पिछली प्रतिक्रिया आईडी

सर्वर-साइड वार्तालाप स्थिति के लिए (स्थानीय सेशन इतिहास को बायपास करते हुए), 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()?;

---

स्ट्रीमिंग व्यवहार

Responses API क्लाइंट टेक्स्ट और रीजनिंग डेल्टा को रीयल-टाइम में स्ट्रीम करता है:

• टेक्स्ट डेल्टा partial: true के साथ Part::Text के रूप में आते हैं
• रीजनिंग सारांश डेल्टा partial: true के साथ Part::Thinking के रूप में आते हैं
• फ़ंक्शन कॉल सही नामों और आर्ग्युमेंट के साथ अंतिम ResponseCompleted इवेंट से उत्सर्जित होते हैं
• अंतिम इवेंट में उपयोग मेटाडेटा और समाप्ति कारण के साथ turn_complete: true होता है

इसका अर्थ है कि मॉडल के निर्माण के दौरान आपको टेक्स्ट टोकन-दर-टोकन दिखाई देता है और फ़ंक्शन कॉल निष्पादन के लिए तैयार पूर्ण ऑब्जेक्ट के रूप में आती हैं।

---

प्रोवाइडर मेटाडेटा

हर प्रतिक्रिया में 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
}

अतिरिक्त मेटाडेटा में निम्न शामिल हो सकते हैं:

• encrypted_content — रीजनिंग मॉडल से (संदर्भ संरक्षण के लिए)
• built_in_tool_outputs — वेब सर्च, फ़ाइल सर्च और कोड इंटरप्रेटर के परिणाम

---

त्रुटि प्रबंधन

त्रुटियों को उपयुक्त श्रेणियों के साथ संरचित AdkError में मैप किया जाता है:

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 */ }
}

---

बैकग्राउंड मोड और रद्द करना

लंबे समय तक चलने वाले अनुरोधों के लिए, background: true के साथ सबमिट करें और पूर्णता के लिए पोल करें:

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?;

डीप रिसर्च मॉडल (o3-deep-research, o4-mini-deep-research) स्पष्ट background: true के बिना स्वचालित रूप से बैकग्राउंड मोड सक्षम कर देते हैं।

---

उदाहरण

एक पूर्ण 7-परिदृश्य उदाहरण यहाँ उपलब्ध है: examples/openai_responses/

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

शामिल परिदृश्य:

1. बुनियादी नॉन-स्ट्रीमिंग चैट
2. बुनियादी स्ट्रीमिंग चैट
3. सारांश के साथ रीजनिंग मॉडल (o4-mini संगतता पथ)
4. फ़ंक्शन टूल के साथ टूल कॉलिंग
5. बहु-टर्न वार्तालाप
6. सिस्टम निर्देश
7. तापमान और जनरेशन कॉन्फ़िगरेशन (gpt-4.1-nano संगतता पथ)

अतिरिक्त उदाहरण

छह स्वतंत्र उदाहरण क्रेट विशिष्ट Responses API सुविधाओं को प्रदर्शित करते हैं:

---

संबंधित

• क्लाउड मॉडल प्रदाता — सभी समर्थित LLM प्रदाता
• Ollama (स्थानीय) — मॉडल स्थानीय रूप से चलाएँ
• LlmAgent — एजेंट के साथ मॉडल का उपयोग करना
• फ़ंक्शन टूल — एजेंट में टूल जोड़ना

---

पिछला: ← क्लाउड प्रदाता | अगला: Ollama (स्थानीय) →