API3 Technical Documentation

Basic Request with requests

import requests
import json

def chat_completion(message, model="gpt-5.1"):
    response = requests.post(
        "https://api3.exploit.bot/v1/chat/completions",
        headers={
            "Authorization": "Bearer eric",
            "Content-Type": "application/json"
        },
        json={
            "model": model,
            "messages": [{"role": "user", "content": message}]
        }
    )

    if response.status_code == 200:
        return response.json()["choices"][0]["message"]["content"]
    else:
        raise Exception(f"Error: {response.status_code} - {response.text}")

# Usage
result = chat_completion("Explain quantum computing")
print(result)

Async with aiohttp

import asyncio
import aiohttp
import json

class AsyncAPI3Client:
    def __init__(self, api_key="eric"):
        self.base_url = "https://api3.exploit.bot/v1"
        self.api_key = api_key
        self.session = None

    async def __aenter__(self):
        self.session = aiohttp.ClientSession(
            headers={"Authorization": f"Bearer {self.api_key}"}
        )
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        if self.session:
            await self.session.close()

    async def chat(self, messages, model="gpt-5.1", **kwargs):
        payload = {
            "model": model,
            "messages": messages,
            **kwargs
        }

        async with self.session.post(
            f"{self.base_url}/chat/completions",
            json=payload
        ) as response:
            if response.status == 200:
                data = await response.json()
                return data["choices"][0]["message"]
            else:
                text = await response.text()
                raise Exception(f"Error {response.status}: {text}")

# Usage
async def main():
    async with AsyncAPI3Client() as client:
        response = await client.chat([
            {"role": "user", "content": "Write a Python function"}
        ])
        print(response.content)

asyncio.run(main())

Function Calling

import requests

def call_function_with_tools():
    tools = [
        {
            "type": "function",
            "function": {
                "name": "calculate",
                "description": "Perform mathematical calculations",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "expression": {
                            "type": "string",
                            "description": "Mathematical expression to evaluate"
                        }
                    },
                    "required": ["expression"]
                }
            }
        }
    ]

    messages = [
        {"role": "user", "content": "What is 123 * 456?"}
    ]

    # First request - get function call
    response = requests.post(
        "https://api3.exploit.bot/v1/chat/completions",
        headers={
            "Authorization": "Bearer eric",
            "Content-Type": "application/json"
        },
        json={
            "model": "gpt-5.1-codex",
            "messages": messages,
            "tools": tools,
            "tool_choice": "required"
        }
    )

    data = response.json()
    tool_call = data["choices"][0]["message"]["tool_calls"][0]

    # Execute the function
    function_name = tool_call["function"]["name"]
    arguments = json.loads(tool_call["function"]["arguments"])

    if function_name == "calculate":
        result = eval(arguments["expression"])  # Be careful with eval in production!

        # Send result back
        messages.append(data["choices"][0]["message"])
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call["id"],
            "content": json.dumps({"result": result})
        })

        # Second request - get final response
        final_response = requests.post(
            "https://api3.exploit.bot/v1/chat/completions",
            headers={
                "Authorization": "Bearer eric",
                "Content-Type": "application/json"
            },
            json={
                "model": "gpt-5.1-codex",
                "messages": messages
            }
        )

        return final_response.json()["choices"][0]["message"]["content"]

# Usage
result = call_function_with_tools()
print(result)

Streaming with requests

def stream_chat(message, on_chunk=None):
    response = requests.post(
        "https://api3.exploit.bot/v1/chat/completions",
        headers={
            "Authorization": "Bearer eric",
            "Content-Type": "application/json"
        },
        json={
            "model": "gpt-5.1-codex",
            "messages": [{"role": "user", "content": message}],
            "stream": True
        },
        stream=True
    )

    full_content = ""

    for line in response.iter_lines():
        if line:
            line = line.decode('utf-8')
            if line.startswith('data: '):
                data = line[6:]
                if data == '[DONE]':
                    break

                try:
                    chunk = json.loads(data)
                    delta = chunk.get('choices', [{}])[0].get('delta', {})

                    if 'content' in delta:
                        content = delta['content']
                        full_content += content
                        if on_chunk:
                            on_chunk(content)
                        print(content, end='', flush=True)
                except json.JSONDecodeError:
                    continue

    return full_content

# Usage
result = stream_chat("Tell me a joke")
print(f"\n\nComplete: {result}")

With OpenAI SDK

from openai import OpenAI

client = OpenAI(
    api_key="eric",
    base_url="https://api3.exploit.bot/v1"
)

def chat_with_sdk(message):
    response = client.chat.completions.create(
        model="gpt-5.1",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": message}
        ],
        temperature=0.7,
        max_tokens=1000
    )

    return response.choices[0].message.content

def stream_with_sdk(message):
    stream = client.chat.completions.create(
        model="gpt-5.1",
        messages=[{"role": "user", "content": message}],
        stream=True
    )

    full_response = ""
    for chunk in stream:
        content = chunk.choices[0].delta.content
        if content:
            full_response += content
            print(content, end='', flush=True)

    return full_response

def function_calling_with_sdk():
    tools = [
        {
            "type": "function",
            "function": {
                "name": "get_stock_price",
                "description": "Get current stock price",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "symbol": {"type": "string"},
                        "currency": {"type": "string", "enum": ["USD", "EUR"]}
                    },
                    "required": ["symbol"]
                }
            }
        }
    ]

    response = client.chat.completions.create(
        model="gpt-5.1",
        messages=[{"role": "user", "content": "What's AAPL stock price?"}],
        tools=tools,
        tool_choice="auto"
    )

    return response.choices[0].message

Basic Fetch API

class API3Client {
    constructor(apiKey = 'eric') {
        this.baseURL = 'https://api3.exploit.bot/v1';
        this.apiKey = apiKey;
    }

    async chat(messages, options = {}) {
        const response = await fetch(`${this.baseURL}/chat/completions`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${this.apiKey}`
            },
            body: JSON.stringify({
                model: options.model || 'gpt-5.1',
                messages,
                stream: false,
                ...options
            })
        });

        if (!response.ok) {
            const error = await response.json();
            throw new Error(`Error: ${response.status} - ${error.detail?.message || 'Unknown error'}`);
        }

        const data = await response.json();
        return data.choices[0].message;
    }

    async stream(messages, onChunk, options = {}) {
        const response = await fetch(`${this.baseURL}/chat/completions`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${this.apiKey}`
            },
            body: JSON.stringify({
                model: options.model || 'gpt-5.1',
                messages,
                stream: true,
                ...options
            })
        });

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

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

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

            buffer += decoder.decode(value);
            const lines = buffer.split('\n');
            buffer = lines.pop();

            for (const line of lines) {
                if (line.startsWith('data: ')) {
                    const data = line.slice(6);
                    if (data === '[DONE]') return;

                    try {
                        const chunk = JSON.parse(data);
                        const delta = chunk.choices[0]?.delta;

                        if (delta?.content) {
                            onChunk(delta.content, chunk);
                        }
                    } catch (e) {
                        console.error('Parse error:', e);
                    }
                }
            }
        }
    }
}

// Usage
const client = new API3Client();

// Basic chat
client.chat([
    { role: 'user', content: 'Hello!' }
]).then(response => {
    console.log(response.content);
});

// Streaming
client.stream(
    [{ role: 'user', content: 'Write a poem' }],
    (chunk) => process.stdout.write(chunk)
).then(() => {
    console.log('\nStream complete');
});

Function Calling

async function functionCallingExample() {
    const tools = [
        {
            type: 'function',
            function: {
                name: 'send_email',
                description: 'Send an email to a recipient',
                parameters: {
                    type: 'object',
                    properties: {
                        to: { type: 'string', description: 'Email address' },
                        subject: { type: 'string', description: 'Email subject' },
                        body: { type: 'string', description: 'Email body' }
                    },
                    required: ['to', 'subject', 'body']
                }
            }
        }
    ];

    const messages = [
        { role: 'user', content: 'Send an email to john@example.com about the meeting' }
    ];

    // Get function call
    const response = await fetch('https://api3.exploit.bot/v1/chat/completions', {
        method: 'POST',
        headers: {
            'Authorization': 'Bearer eric',
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            model: 'gpt-5.1',
            messages,
            tools,
            tool_choice: 'required'
        })
    });

    const data = await response.json();
    const toolCall = data.choices[0].message.tool_calls[0];

    // Execute function (mock implementation)
    const args = JSON.parse(toolCall.function.arguments);
    const emailResult = await sendEmail(args.to, args.subject, args.body);

    // Continue conversation with result
    messages.push(data.choices[0].message);
    messages.push({
        role: 'tool',
        tool_call_id: toolCall.id,
        content: JSON.stringify({ success: true, messageId: emailResult.id })
    });

    const finalResponse = await fetch('https://api3.exploit.bot/v1/chat/completions', {
        method: 'POST',
        headers: {
            'Authorization': 'Bearer eric',
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            model: 'gpt-5.1',
            messages
        })
    });

    const finalData = await finalResponse.json();
    return finalData.choices[0].message.content;
}

Streaming with EventSource

function streamingWithEventSource(messages) {
    // Note: EventSource doesn't support POST, so we need to use fetch for streaming

    const eventSource = new EventSource('/stream-endpoint'); // If you have a proxy

    eventSource.onmessage = (event) => {
        const data = JSON.parse(event.data);
        console.log('Received:', data);
    };

    // Better approach: Use fetch with streaming as shown above
}

Error Handling

async function robustChat(message, retries = 3) {
    for (let attempt = 1; attempt <= retries; attempt++) {
        try {
            const response = await fetch('https://api3.exploit.bot/v1/chat/completions', {
                method: 'POST',
                headers: {
                    'Authorization': 'Bearer eric',
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    model: 'gpt-5.1',
                    messages: [{ role: 'user', content: message }]
                })
            });

            if (response.ok) {
                const data = await response.json();
                return data.choices[0].message.content;
            } else if (response.status === 429) {
                // Rate limited - wait and retry
                const retryAfter = response.headers.get('Retry-After') || 1;
                await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
                continue;
            } else {
                const error = await response.json();
                throw new Error(error.detail?.message || `HTTP ${response.status}`);
            }
        } catch (error) {
            console.error(`Attempt ${attempt} failed:`, error);

            if (attempt === retries) {
                throw error;
            }

            // Exponential backoff
            await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
        }
    }
}

TypeScript Client

interface Message {
    role: 'system' | 'user' | 'assistant' | 'tool';
    content?: string;
    tool_calls?: ToolCall[];
    tool_call_id?: string;
}

interface ToolCall {
    id: string;
    type: 'function';
    function: {
        name: string;
        arguments: string;
    };
}

interface Tool {
    type: 'function';
    function: {
        name: string;
        description: string;
        parameters: Record;
    };
}

interface ChatCompletionRequest {
    model: string;
    messages: Message[];
    stream?: boolean;
    temperature?: number;
    max_tokens?: number;
    tools?: Tool[];
    tool_choice?: 'auto' | 'required' | 'none' | { type: 'function'; function: { name: string } };
    parallel_tool_calls?: boolean;
    x_codex?: {
        reasoning_effort?: 'minimal' | 'low' | 'medium' | 'high';
        sandbox?: 'read-only' | 'danger-full-access';
        network_access?: boolean;
        hide_reasoning?: boolean;
    };
}

interface ChatCompletionResponse {
    id: string;
    object: 'chat.completion';
    created: number;
    model: string;
    choices: Array<{
        index: number;
        message: Message;
        finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter';
    }>;
    usage: {
        prompt_tokens: number;
        completion_tokens: number;
        total_tokens: number;
    };
}

class API3Client {
    private readonly baseURL: string;
    private readonly apiKey: string;

    constructor(apiKey: string = 'eric', baseURL: string = 'https://api3.exploit.bot/v1') {
        this.apiKey = apiKey;
        this.baseURL = baseURL;
    }

    async chat(request: ChatCompletionRequest): Promise {
        const response = await fetch(`${this.baseURL}/chat/completions`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${this.apiKey}`
            },
            body: JSON.stringify({
                model: 'gpt-5.1',
                ...request
            })
        });

        if (!response.ok) {
            const error = await response.json() as any;
            throw new Error(`API Error: ${response.status} - ${error.detail?.message || 'Unknown'}`);
        }

        return response.json();
    }

    async stream(request: ChatCompletionRequest): Promise> {
        const response = await fetch(`${this.baseURL}/chat/completions`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${this.apiKey}`
            },
            body: JSON.stringify({
                ...request,
                stream: true
            })
        });

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

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

        if (!reader) {
            throw new Error('No response body');
        }

        return this.parseStream(reader, decoder);
    }

    private async *parseStream(reader: ReadableStreamDefaultReader, decoder: TextDecoder): AsyncGenerator {
        let buffer = '';

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

            buffer += decoder.decode(value);
            const lines = buffer.split('\n');
            buffer = lines.pop() || '';

            for (const line of lines) {
                if (line.startsWith('data: ')) {
                    const data = line.slice(6);
                    if (data === '[DONE]') return;

                    try {
                        const chunk = JSON.parse(data) as ChatCompletionResponse;
                        yield chunk;
                    } catch (e) {
                        console.error('Parse error:', e);
                    }
                }
            }
        }
    }
}

// Usage Example
const client = new API3Client();

// Basic chat with type safety
async function example() {
    const messages: Message[] = [
        { role: 'system', content: 'You are a TypeScript expert.' },
        { role: 'user', content: 'Explain generics in TypeScript' }
    ];

    const response = await client.chat({
        model: 'gpt-5.1',
        messages,
        temperature: 0.7
    });

    console.log(response.choices[0].message.content);
}

// Function calling with types
async function functionCallingExample() {
    const tools: Tool[] = [
        {
            type: 'function',
            function: {
                name: 'create_file',
                description: 'Create a file with content',
                parameters: {
                    type: 'object',
                    properties: {
                        path: { type: 'string' },
                        content: { type: 'string' }
                    },
                    required: ['path', 'content']
                }
            }
        }
    ];

    const messages: Message[] = [
        { role: 'user', content: 'Create a TypeScript file with a hello world function' }
    ];

    const response = await client.chat({
        model: 'gpt-5.1-codex',
        messages,
        tools,
        tool_choice: 'auto'
    });

    // Type-safe function call handling
    const toolCalls = response.choices[0].message.tool_calls;
    if (toolCalls) {
        for (const toolCall of toolCalls) {
            console.log(`Calling ${toolCall.function.name} with args:`, toolCall.function.arguments);
        }
    }
}

React Hook

import { useState, useCallback } from 'react';

interface UseChatOptions {
    model?: string;
    temperature?: number;
    onStream?: (chunk: string) => void;
    onError?: (error: Error) => void;
}

export function useChat(options: UseChatOptions = {}) {
    const [loading, setLoading] = useState(false);
    const [messages, setMessages] = useState([]);
    const [error, setError] = useState(null);

    const sendMessage = useCallback(async (content: string) => {
        setLoading(true);
        setError(null);

        const newMessage: Message = { role: 'user', content };
        setMessages(prev => [...prev, newMessage]);

        try {
            const response = await fetch('https://api3.exploit.bot/v1/chat/completions', {
                method: 'POST',
                headers: {
                    'Authorization': 'Bearer eric',
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    model: options.model || 'gpt-5.1',
                    messages: [...messages, newMessage],
                    temperature: options.temperature || 0.7
                })
            });

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

            const data = await response.json();
            const assistantMessage = data.choices[0].message;

            setMessages(prev => [...prev, assistantMessage]);
            return assistantMessage;
        } catch (err) {
            const error = err as Error;
            setError(error);
            options.onError?.(error);
            throw error;
        } finally {
            setLoading(false);
        }
    }, [messages, options]);

    const streamMessage = useCallback(async (content: string) => {
        setLoading(true);
        setError(null);

        const newMessage: Message = { role: 'user', content };
        setMessages(prev => [...prev, newMessage]);

        try {
            const response = await fetch('https://api3.exploit.bot/v1/chat/completions', {
                method: 'POST',
                headers: {
                    'Authorization': 'Bearer eric',
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({
                    model: options.model || 'gpt-5.1',
                    messages: [...messages, newMessage],
                    stream: true
                })
            });

            const reader = response.body?.getReader();
            const decoder = new TextDecoder();
            let assistantContent = '';

            if (reader) {
                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 {
                                const parsed = JSON.parse(data);
                                const delta = parsed.choices[0]?.delta;

                                if (delta?.content) {
                                    assistantContent += delta.content;
                                    options.onStream?.(delta.content);
                                }
                            } catch (e) {
                                // Ignore parse errors
                            }
                        }
                    }
                }
            }

            const assistantMessage: Message = {
                role: 'assistant',
                content: assistantContent
            };

            setMessages(prev => [...prev, assistantMessage]);
            return assistantMessage;
        } catch (err) {
            const error = err as Error;
            setError(error);
            options.onError?.(error);
            throw error;
        } finally {
            setLoading(false);
        }
    }, [messages, options]);

    return {
        messages,
        loading,
        error,
        sendMessage,
        streamMessage,
        clearMessages: () => setMessages([])
    };
}

// Usage in component
function ChatComponent() {
    const { messages, loading, sendMessage, streamMessage } = useChat({
        model: 'gpt-5.1',
        onStream: (chunk) => console.log('Received:', chunk)
    });

    const handleSubmit = async (e: React.FormEvent) => {
        e.preventDefault();
        const formData = new FormData(e.target as HTMLFormElement);
        const message = formData.get('message') as string;

        await streamMessage(message);
    };

    return (
        

            

                {messages.map((msg, i) => (
                    

                        {msg.role}: {msg.content}
                    
                ))}
            

            {loading && 
Typing...
}

            

                
                Send
            
        
    );
}

Python OpenAI SDK

from openai import OpenAI

# Initialize client with API3
client = OpenAI(
    api_key="eric",
    base_url="https://api3.exploit.bot/v1"
)

# Basic chat
def basic_chat():
    response = client.chat.completions.create(
        model="gpt-5.1",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "Explain the theory of relativity"}
        ],
        temperature=0.7,
        max_tokens=500
    )

    return response.choices[0].message.content

# Streaming
def streaming_example():
    stream = client.chat.completions.create(
        model="gpt-5.1",
        messages=[{"role": "user", "content": "Write a story"}],
        stream=True,
        temperature=0.8
    )

    full_response = ""
    for chunk in stream:
        content = chunk.choices[0].delta.content
        if content:
            full_response += content
            print(content, end='', flush=True)

    return full_response

# Function calling
def function_calling_example():
    tools = [
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Get current weather for a location",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "City and state, e.g. San Francisco, CA"
                        },
                        "unit": {
                            "type": "string",
                            "enum": ["celsius", "fahrenheit"]
                        }
                    },
                    "required": ["location"]
                }
            }
        },
        {
            "type": "function",
            "function": {
                "name": "calculate_tip",
                "description": "Calculate tip amount",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "bill_amount": {"type": "number"},
                        "tip_percentage": {"type": "number"}
                    },
                    "required": ["bill_amount"]
                }
            }
        }
    ]

    response = client.chat.completions.create(
        model="gpt-5.1",
        messages=[
            {"role": "user", "content": "What's the weather in Boston and calculate a 20% tip on a $50 bill?"}
        ],
        tools=tools,
        parallel_tool_calls=True,
        tool_choice="auto"
    )

    return response.choices[0].message

# Using codex-cli with reasoning effort
def codex_reasoning_example():
    response = client.chat.completions.create(
        model="codex-cli high",
        messages=[
            {"role": "user", "content": "Implement a binary search tree in Python with all operations"}
        ],
        x_codex={
            "reasoning_effort": "high",
            "sandbox": "read-only",
            "hide_reasoning": False
        }
    )

    return response.choices[0].message.content

JavaScript/TypeScript OpenAI SDK

import OpenAI from 'openai';

// Initialize client
const openai = new OpenAI({
    apiKey: 'eric',
    baseURL: 'https://api3.exploit.bot/v1',
    dangerouslyAllowBrowser: true // Only for browser usage
});

// Basic chat completion
async function basicChat() {
    const completion = await openai.chat.completions.create({
        model: 'gpt-5.1',
        messages: [
            { role: 'system', content: 'You are a helpful assistant.' },
            { role: 'user', content: 'Explain JavaScript closures' }
        ],
        temperature: 0.7,
        max_tokens: 500
    });

    return completion.choices[0].message.content;
}

// Streaming with SDK
async function streamingChat() {
    const stream = await openai.chat.completions.create({
        model: 'gpt-5.1',
        messages: [
            { role: 'user', content: 'Write a mystery story' }
        ],
        stream: true
    });

    let fullResponse = '';

    for await (const chunk of stream) {
        const content = chunk.choices[0]?.delta?.content;
        if (content) {
            fullResponse += content;
            process.stdout.write(content);
        }
    }

    return fullResponse;
}

// Function calling with SDK
async function functionCalling() {
    const tools = [
        {
            type: 'function',
            function: {
                name: 'search_web',
                description: 'Search the web for information',
                parameters: {
                    type: 'object',
                    properties: {
                        query: {
                            type: 'string',
                            description: 'Search query'
                        },
                        num_results: {
                            type: 'number',
                            description: 'Number of results to return'
                        }
                    },
                    required: ['query']
                }
            }
        }
    ];

    const response = await openai.chat.completions.create({
        model: 'gpt-5.1',
        messages: [
            { role: 'user', content: 'Search for recent AI breakthroughs' }
        ],
        tools,
        tool_choice: 'auto'
    });

    const toolCalls = response.choices[0].message.tool_calls;
    if (toolCalls) {
        for (const toolCall of toolCalls) {
            console.log(`Function: ${toolCall.function.name}`);
            console.log(`Args: ${toolCall.function.arguments}`);
        }
    }

    return response.choices[0].message;
}

// Advanced usage with custom logic
class ChatAssistant {
    private client: OpenAI;
    private conversation: Array = [];

    constructor(model: string = 'gpt-5.1') {
        this.client = new OpenAI({
            apiKey: 'eric',
            baseURL: 'https://api3.exploit.bot/v1'
        });
    }

    async addMessage(role: 'user' | 'assistant', content: string) {
        this.conversation.push({ role, content });
    }

    async respond(useTools = false) {
        const response = await this.client.chat.completions.create({
            model: 'gpt-5.1',
            messages: this.conversation,
            tools: useTools ? this.getTools() : undefined,
            tool_choice: useTools ? 'auto' : undefined
        });

        const message = response.choices[0].message;
        this.conversation.push(message as any);

        // Handle tool calls
        if (message.tool_calls) {
            const results = await this.executeToolCalls(message.tool_calls);

            // Add tool results and get final response
            for (const result of results) {
                this.conversation.push({
                    role: 'tool',
                    tool_call_id: result.tool_call_id,
                    content: result.content
                });
            }

            return this.respond(false); // Get final response without tools
        }

        return message.content;
    }

    private getTools() {
        return [
            {
                type: 'function' as const,
                function: {
                    name: 'get_current_time',
                    description: 'Get current time',
                    parameters: { type: 'object', properties: {} }
                }
            }
        ];
    }

    private async executeToolCalls(toolCalls: OpenAI.Chat.Completions.ChatCompletionMessageToolCall[]) {
        const results = [];

        for (const toolCall of toolCalls) {
            if (toolCall.function.name === 'get_current_time') {
                results.push({
                    tool_call_id: toolCall.id,
                    content: new Date().toISOString()
                });
            }
        }

        return results;
    }
}

// Usage
const assistant = new ChatAssistant();
await assistant.addMessage('user', 'What time is it?');
const response = await assistant.respond(true);
console.log(response);

package main

import (
    "bytes"
    "context"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "time"
)

// Structs for API requests and responses
type Message struct {
    Role       string `json:"role"`
    Content    string `json:"content,omitempty"`
    ToolCalls  []ToolCall `json:"tool_calls,omitempty"`
    ToolCallID string `json:"tool_call_id,omitempty"`
}

type ToolCall struct {
    ID       string `json:"id"`
    Type     string `json:"type"`
    Function struct {
        Name      string `json:"name"`
        Arguments string `json:"arguments"`
    } `json:"function"`
}

type Tool struct {
    Type     string `json:"type"`
    Function struct {
        Name        string                 `json:"name"`
        Description string                 `json:"description"`
        Parameters  map[string]interface{} `json:"parameters"`
    } `json:"function"`
}

type ChatRequest struct {
    Model              string    `json:"model"`
    Messages           []Message `json:"messages"`
    Stream             bool      `json:"stream,omitempty"`
    Temperature        float64   `json:"temperature,omitempty"`
    MaxTokens          int       `json:"max_tokens,omitempty"`
    Tools              []Tool    `json:"tools,omitempty"`
    ToolChoice         string    `json:"tool_choice,omitempty"`
    ParallelToolCalls  bool      `json:"parallel_tool_calls,omitempty"`
    XCodex             *XCodex   `json:"x_codex,omitempty"`
}

type XCodex struct {
    ReasoningEffort string `json:"reasoning_effort,omitempty"`
    Sandbox         string `json:"sandbox,omitempty"`
    NetworkAccess   bool   `json:"network_access,omitempty"`
    HideReasoning   bool   `json:"hide_reasoning,omitempty"`
}

type ChatResponse struct {
    ID      string `json:"id"`
    Object  string `json:"object"`
    Created int64  `json:"created"`
    Model   string `json:"model"`
    Choices []struct {
        Index        int     `json:"index"`
        Message      Message `json:"message"`
        FinishReason string  `json:"finish_reason"`
    } `json:"choices"`
    Usage struct {
        PromptTokens     int `json:"prompt_tokens"`
        CompletionTokens int `json:"completion_tokens"`
        TotalTokens      int `json:"total_tokens"`
    } `json:"usage"`
}

// Client struct
type API3Client struct {
    BaseURL string
    APIKey  string
    Client  *http.Client
}

func NewClient(apiKey string) *API3Client {
    return &API3Client{
        BaseURL: "https://api3.exploit.bot/v1",
        APIKey:  apiKey,
        Client: &http.Client{
            Timeout: 120 * time.Second,
        },
    }
}

// Basic chat completion
func (c *API3Client) Chat(ctx context.Context, req ChatRequest) (*ChatResponse, error) {
    req.Stream = false // Ensure non-streaming

    jsonData, err := json.Marshal(req)
    if err != nil {
        return nil, err
    }

    httpReq, err := http.NewRequestWithContext(ctx, "POST", c.BaseURL+"/chat/completions", bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, err
    }

    httpReq.Header.Set("Content-Type", "application/json")
    httpReq.Header.Set("Authorization", "Bearer "+c.APIKey)

    resp, err := c.Client.Do(httpReq)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        body, _ := io.ReadAll(resp.Body)
        return nil, fmt.Errorf("API error: %d - %s", resp.StatusCode, string(body))
    }

    var result ChatResponse
    err = json.NewDecoder(resp.Body).Decode(&result)
    return &result, err
}

// Streaming chat
func (c *API3Client) ChatStream(ctx context.Context, req ChatRequest, callback func(*ChatResponse) error) error {
    req.Stream = true

    jsonData, err := json.Marshal(req)
    if err != nil {
        return err
    }

    httpReq, err := http.NewRequestWithContext(ctx, "POST", c.BaseURL+"/chat/completions", bytes.NewBuffer(jsonData))
    if err != nil {
        return err
    }

    httpReq.Header.Set("Content-Type", "application/json")
    httpReq.Header.Set("Authorization", "Bearer "+c.APIKey)
    httpReq.Header.Set("Accept", "text/event-stream")

    resp, err := c.Client.Do(httpReq)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        body, _ := io.ReadAll(resp.Body)
        return fmt.Errorf("API error: %d - %s", resp.StatusCode, string(body))
    }

    decoder := json.NewDecoder(resp.Body)

    for {
        var line string
        _, err = fmt.Fscanf(resp.Body, "data: %s\n", &line)
        if err != nil {
            if err == io.EOF {
                break
            }
            continue
        }

        if line == "[DONE]" {
            break
        }

        var chunk ChatResponse
        if err := json.Unmarshal([]byte(line), &chunk); err == nil {
            if callback != nil {
                if err := callback(&chunk); err != nil {
                    return err
                }
            }
        }
    }

    return nil
}

// Function calling example
func functionCallingExample() {
    client := NewClient("eric")

    tools := []Tool{
        {
            Type: "function",
            Function: struct {
                Name        string                 `json:"name"`
                Description string                 `json:"description"`
                Parameters  map[string]interface{} `json:"parameters"`
            }{
                Name:        "calculate",
                Description: "Perform mathematical calculations",
                Parameters: map[string]interface{}{
                    "type": "object",
                    "properties": map[string]interface{}{
                        "expression": map[string]interface{}{
                            "type":        "string",
                            "description": "Mathematical expression",
                        },
                    },
                    "required": []string{"expression"},
                },
            },
        },
    }

    req := ChatRequest{
        Model: "gpt-5.1",
        Messages: []Message{
            {Role: "user", Content: "What is 15 * 23?"},
        },
        Tools:     tools,
        ToolChoice: "auto",
    }

    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    resp, err := client.Chat(ctx, req)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    // Check for tool calls
    if len(resp.Choices) > 0 && len(resp.Choices[0].Message.ToolCalls) > 0 {
        toolCall := resp.Choices[0].Message.ToolCalls[0]
        fmt.Printf("Function called: %s\n", toolCall.Function.Name)
        fmt.Printf("Arguments: %s\n", toolCall.Function.Arguments)

        // Execute function and continue conversation...
    } else {
        fmt.Printf("Response: %s\n", resp.Choices[0].Message.Content)
    }
}

// Streaming example
func streamingExample() {
    client := NewClient("eric")

    req := ChatRequest{
        Model: "gpt-5.1",
        Messages: []Message{
            {Role: "user", Content: "Write a story about a robot"},
        },
    }

    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    fmt.Print("Streaming: ")
    err := client.ChatStream(ctx, req, func(chunk *ChatResponse) error {
        if len(chunk.Choices) > 0 {
            content := chunk.Choices[0].Message.Content
            if content != "" {
                fmt.Print(content)
            }
        }
        return nil
    })

    if err != nil {
        fmt.Printf("\nError: %v\n", err)
    } else {
        fmt.Println("\n\nStream complete")
    }
}

func main() {
    // Basic example
    client := NewClient("eric")

    req := ChatRequest{
        Model: "gpt-5.1",
        Messages: []Message{
            {Role: "system", Content: "You are a helpful assistant."},
            {Role: "user", Content: "Explain Go concurrency"},
        },
        Temperature: 0.7,
    }

    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    resp, err := client.Chat(ctx, req)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        os.Exit(1)
    }

    fmt.Printf("Response: %s\n", resp.Choices[0].Message.Content)

    // Run other examples
    functionCallingExample()
    streamingExample()
}

use reqwest;
use serde::{Deserialize, Serialize};
use serde_json::json;
use std::collections::HashMap;
use tokio_stream::StreamExt;
use futures::Stream;

// API structs
#[derive(Debug, Serialize, Deserialize)]
struct Message {
    role: String,
    content: Option,
    tool_calls: Option>,
    tool_call_id: Option,
}

#[derive(Debug, Serialize, Deserialize)]
struct ToolCall {
    id: String,
    r#type: String,
    function: FunctionCall,
}

#[derive(Debug, Serialize, Deserialize)]
struct FunctionCall {
    name: String,
    arguments: String,
}

#[derive(Debug, Serialize)]
struct Tool {
    r#type: String,
    function: FunctionDef,
}

#[derive(Debug, Serialize)]
struct FunctionDef {
    name: String,
    description: String,
    parameters: serde_json::Value,
}

#[derive(Debug, Serialize)]
struct ChatRequest {
    model: String,
    messages: Vec,
    stream: Option,
    temperature: Option,
    max_tokens: Option,
    tools: Option>,
    tool_choice: Option,
    parallel_tool_calls: Option,
    x_codex: Option,
}

#[derive(Debug, Serialize)]
struct XCodex {
    reasoning_effort: Option,
    sandbox: Option,
    network_access: Option,
    hide_reasoning: Option,
}

#[derive(Debug, Deserialize)]
struct ChatResponse {
    id: String,
    object: String,
    created: u64,
    model: String,
    choices: Vec,
    usage: Usage,
}

#[derive(Debug, Deserialize)]
struct Choice {
    index: u32,
    message: Message,
    finish_reason: String,
}

#[derive(Debug, Deserialize)]
struct Usage {
    prompt_tokens: u32,
    completion_tokens: u32,
    total_tokens: u32,
}

// Client struct
struct API3Client {
    base_url: String,
    api_key: String,
    client: reqwest::Client,
}

impl API3Client {
    fn new(api_key: &str) -> Self {
        Self {
            base_url: "https://api3.exploit.bot/v1".to_string(),
            api_key: api_key.to_string(),
            client: reqwest::Client::new(),
        }
    }

    async fn chat(&self, request: ChatRequest) -> Result> {
        let url = format!("{}/chat/completions", self.base_url);

        let mut req_body = request;
        req_body.stream = Some(false);

        let response = self.client
            .post(&url)
            .header("Authorization", format!("Bearer {}", self.api_key))
            .header("Content-Type", "application/json")
            .json(&req_body)
            .send()
            .await?;

        if !response.status().is_success() {
            let error_text = response.text().await?;
            return Err(format!("API error: {}", error_text).into());
        }

        let chat_response: ChatResponse = response.json().await?;
        Ok(chat_response)
    }

    async fn chat_stream(
        &self,
        request: ChatRequest,
    ) -> Result>>, Box> {
        let url = format!("{}/chat/completions", self.base_url);

        let mut req_body = request;
        req_body.stream = Some(true);

        let response = self.client
            .post(&url)
            .header("Authorization", format!("Bearer {}", self.api_key))
            .header("Content-Type", "application/json")
            .json(&req_body)
            .send()
            .await?;

        if !response.status().is_success() {
            let error_text = response.text().await?;
            return Err(format!("API error: {}", error_text).into());
        }

        let byte_stream = response.bytes_stream();
        let line_stream = byte_stream
            .map(|result| {
                result.map_err(|e| Box::new(e) as Box)
            })
            .scan(Vec::new(), |buffer, chunk| {
                async move {
                    let chunk = chunk?;
                    buffer.extend_from_slice(&chunk);

                    let mut lines = Vec::new();
                    while let Some(newline_pos) = buffer.iter().position(|&b| b == b'\n') {
                        let line = buffer.drain(..=newline_pos).collect::>();
                        let line_str = String::from_utf8_lossy(&line[..line.len()-1]);
                        lines.push(line_str.to_string());
                    }

                    Some(Ok(lines))
                }
            })
            .flat_map(futures::stream::iter);

        let chunk_stream = line_stream
            .filter_map(|lines_result| async move {
                match lines_result {
                    Ok(lines) => Some(futures::stream::iter(lines).collect::>()),
                    Err(e) => Some(futures::stream::iter(vec![Err(e)]).collect::>()),
                }
            })
            .flatten()
            .filter_map(|line_result| async move {
                match line_result {
                    Ok(line) => {
                        if line.starts_with("data: ") {
                            let data = &line[6..];
                            if data == "[DONE]" {
                                None
                            } else {
                                match serde_json::from_str::(data) {
                                    Ok(chunk) => Some(Ok(chunk)),
                                    Err(e) => Some(Err(Box::new(e))),
                                }
                            }
                        } else {
                            None
                        }
                    }
                    Err(e) => Some(Err(e)),
                }
            });

        Ok(chunk_stream)
    }
}

// Basic usage example
#[tokio::main]
async fn main() -> Result<(), Box> {
    let client = API3Client::new("eric");

    // Basic chat
    let request = ChatRequest {
        model: "gpt-5.1".to_string(),
        messages: vec![
            Message {
                role: "system".to_string(),
                content: Some("You are a helpful Rust assistant.".to_string()),
                tool_calls: None,
                tool_call_id: None,
            },
            Message {
                role: "user".to_string(),
                content: Some("Explain Rust's ownership system".to_string()),
                tool_calls: None,
                tool_call_id: None,
            },
        ],
        stream: None,
        temperature: Some(0.7),
        max_tokens: Some(500),
        tools: None,
        tool_choice: None,
        parallel_tool_calls: None,
        x_codex: None,
    };

    let response = client.chat(request).await?;
    println!("Response: {}", response.choices[0].message.content.as_ref().unwrap());

    // Function calling example
    let tools = vec![
        Tool {
            r#type: "function".to_string(),
            function: FunctionDef {
                name: "execute_code".to_string(),
                description: "Execute code and return result".to_string(),
                parameters: json!({
                    "type": "object",
                    "properties": {
                        "code": {
                            "type": "string",
                            "description": "Code to execute"
                        },
                        "language": {
                            "type": "string",
                            "enum": ["python", "javascript", "rust"],
                            "description": "Programming language"
                        }
                    },
                    "required": ["code", "language"]
                }),
            },
        },
    ];

    let tool_request = ChatRequest {
        model: "gpt-5.1".to_string(),
        messages: vec![
            Message {
                role: "user".to_string(),
                content: Some("Calculate the factorial of 10".to_string()),
                tool_calls: None,
                tool_call_id: None,
            },
        ],
        tools: Some(tools),
        tool_choice: Some(json!("auto")),
        parallel_tool_calls: Some(true),
        ..Default::default()
    };

    let tool_response = client.chat(tool_request).await?;

    if let Some(tool_calls) = &tool_response.choices[0].message.tool_calls {
        for tool_call in tool_calls {
            println!("Function: {}", tool_call.function.name);
            println!("Args: {}", tool_call.function.arguments);

            // Execute function and continue conversation...
        }
    } else {
        println!("No function calls made");
    }

    // Streaming example
    println!("\nStreaming:");
    let stream_request = ChatRequest {
        model: "gpt-5.1".to_string(),
        messages: vec![
            Message {
                role: "user".to_string(),
                content: Some("Write a poem about programming".to_string()),
                tool_calls: None,
                tool_call_id: None,
            },
        ],
        ..Default::default()
    };

    let mut stream = client.chat_stream(stream_request).await?;

    while let Some(chunk_result) = stream.next().await {
        match chunk_result {
            Ok(chunk) => {
                if let Some(content) = chunk.choices.get(0).and_then(|c| c.message.content.as_ref()) {
                    print!("{}", content);
                }
            }
            Err(e) => {
                eprintln!("Stream error: {:?}", e);
                break;
            }
        }
    }

    println!("\n\nStream complete");

    Ok(())
}

// Helper macro for Default implementation
macro_rules! default {
    ($struct_name:ident { $($field:ident: $default:expr),* }) => {
        impl Default for $struct_name {
            fn default() -> Self {
                $struct_name {
                    $($field: $default),*,
                    ..Default::default()
                }
            }
        }
    };
}

// Implement Default for ChatRequest
impl Default for ChatRequest {
    fn default() -> Self {
        Self {
            model: String::new(),
            messages: Vec::new(),
            stream: None,
            temperature: None,
            max_tokens: None,
            tools: None,
            tool_choice: None,
            parallel_tool_calls: None,
            x_codex: None,
        }
    }
}

impl Default for Message {
    fn default() -> Self {
        Self {
            role: String::new(),
            content: None,
            tool_calls: None,
            tool_call_id: None,
        }
    }
}