GPT-OSS Open-Weight Reasoning Models: Complete Guide 2025

import requests
import asyncio
import aiohttp
from typing import Optional

class GPTOSSClient:
    def __init__(self, base_url: str, api_key: Optional[str] = None):
        self.base_url = base_url.rstrip('/')
        self.api_key = api_key
        self.session = requests.Session()
        
        if api_key:
            self.session.headers.update({"Authorization": f"Bearer {api_key}"})
    
    def generate(self, prompt: str, **kwargs) -> dict:
        """Synchronous text generation"""
        response = self.session.post(
            f"{self.base_url}/v1/inference",
            json={"prompt": prompt, **kwargs}
        )
        response.raise_for_status()
        return response.json()
    
    async def generate_async(self, prompt: str, **kwargs) -> dict:
        """Asynchronous text generation"""
        async with aiohttp.ClientSession() as session:
            headers = {}
            if self.api_key:
                headers["Authorization"] = f"Bearer {self.api_key}"
            
            async with session.post(
                f"{self.base_url}/v1/inference",
                json={"prompt": prompt, **kwargs},
                headers=headers
            ) as response:
                response.raise_for_status()
                return await response.json()

# Usage example
client = GPTOSSClient("http://localhost:8000")

# Synchronous usage
result = client.generate(
    prompt="Explain quantum computing in simple terms:",
    max_tokens=300,
    reasoning_mode=True
)

print(result["text"])
if result["reasoning_steps"]:
    print("\nReasoning steps:")
    for i, step in enumerate(result["reasoning_steps"], 1):
        print(f"{i}. {step}")

# Asynchronous usage
async def async_example():
    result = await client.generate_async(
        prompt="What are the implications of artificial general intelligence?",
        max_tokens=500,
        temperature=0.8
    )
    return result

asyncio.run(async_example())
                                    

class GPTOSSClient {
    constructor(baseUrl, apiKey = null) {
        this.baseUrl = baseUrl.replace(/\/$/, '');
        this.apiKey = apiKey;
    }

    async generate(prompt, options = {}) {
        const headers = {
            'Content-Type': 'application/json'
        };
        
        if (this.apiKey) {
            headers['Authorization'] = `Bearer ${this.apiKey}`;
        }

        const response = await fetch(`${this.baseUrl}/v1/inference`, {
            method: 'POST',
            headers: headers,
            body: JSON.stringify({
                prompt: prompt,
                ...options
            })
        });

        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }

        return await response.json();
    }

    async *generateStream(prompt, options = {}) {
        // Streaming implementation for real-time responses
        const response = await fetch(`${this.baseUrl}/v1/inference/stream`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Accept': 'text/event-stream'
            },
            body: JSON.stringify({
                prompt: prompt,
                stream: true,
                ...options
            })
        });

        const reader = response.body.getReader();
        const decoder = new TextDecoder();

        while (true) {
            const { done, value } = await reader.read();
            if (done) break;

            const chunk = decoder.decode(value);
            const lines = chunk.split('\n');

            for (const line of lines) {
                if (line.startsWith('data: ')) {
                    const data = line.slice(6);
                    if (data === '[DONE]') return;
                    
                    try {
                        yield JSON.parse(data);
                    } catch (e) {
                        console.warn('Failed to parse SSE data:', data);
                    }
                }
            }
        }
    }
}

// Usage example
const client = new GPTOSSClient('http://localhost:8000');

// Basic generation
client.generate('Explain machine learning concepts:', {
    max_tokens: 400,
    temperature: 0.7,
    reasoning_mode: true
}).then(result => {
    console.log('Generated text:', result.text);
    console.log('Confidence:', result.confidence);
});

// Streaming example
async function streamExample() {
    console.log('Starting streaming generation...');
    
    for await (const chunk of client.generateStream('Write a story about AI:', {
        max_tokens: 800,
        temperature: 0.8
    })) {
        process.stdout.write(chunk.text || '');
    }
    
    console.log('\nStreaming complete!');
}

streamExample();