/**
 * OpenAI LLM Adapter
 *
 * Wraps the official `openai` npm package for direct integration.
 * The `openai` package must be installed as a peer dependency.
 *
 * Supports two OpenAI API modes:
 * - **`'chat'`** (default): Chat Completions API (`/v1/chat/completions`)
 * - **`'responses'`**: Responses API (`/v1/responses`)
 *
 * @example Chat Completions API (default)
 * ```typescript
 * const adapter = new OpenAIAdapter({ model: 'gpt-4o', apiKey: 'sk-...' });
 * ```
 *
 * @example Responses API
 * ```typescript
 * const adapter = new OpenAIAdapter({ model: 'gpt-4o', apiKey: 'sk-...', api: 'responses' });
 * ```
 *
 * @example Using with pre-configured client
 * ```typescript
 * import OpenAI from 'openai';
 * const adapter = new OpenAIAdapter({ model: 'gpt-4o', client: new OpenAI({ apiKey: 'sk-...' }) });
 * ```
 *
 * @example Using with OpenAI-compatible APIs (Groq, Mistral, etc.)
 * ```typescript
 * const adapter = new OpenAIAdapter({
 *   model: 'llama-3.1-70b-versatile',
 *   apiKey: process.env.GROQ_API_KEY,
 *   baseUrl: 'https://api.groq.com/openai/v1',
 * });
 * ```
 */
import { type AgentCompletion, type AgentCompletionChunk, type AgentCompletionOptions, type AgentLlmAdapter, type AgentMessage, type AgentPrompt, type AgentToolDefinition } from '../../common';
import { BaseLlmAdapter, type BaseLlmAdapterConfig } from './base.adapter';
/**
 * Which OpenAI API to use.
 * - `'chat'`: Chat Completions API (`client.chat.completions.create`)
 * - `'responses'`: Responses API (`client.responses.create`)
 */
export type OpenAIApiMode = 'chat' | 'responses';
interface OpenAIClient {
    chat: {
        completions: {
            create(params: OpenAIChatParams & {
                stream?: false;
            }): Promise<OpenAIChatCompletion>;
            create(params: OpenAIChatParams & {
                stream: true;
            }): Promise<OpenAIChatStream>;
            create(params: OpenAIChatParams): Promise<OpenAIChatCompletion | OpenAIChatStream>;
        };
    };
    responses: {
        create(params: OpenAIResponsesParams & {
            stream?: false;
        }): Promise<OpenAIResponseObject>;
        create(params: OpenAIResponsesParams & {
            stream: true;
        }): Promise<OpenAIResponsesStream>;
        create(params: OpenAIResponsesParams): Promise<OpenAIResponseObject | OpenAIResponsesStream>;
    };
}
interface OpenAIChatParams {
    model: string;
    messages: OpenAIChatMessage[];
    tools?: OpenAIChatTool[];
    tool_choice?: string | {
        type: 'function';
        function: {
            name: string;
        };
    };
    temperature?: number;
    max_tokens?: number;
    stop?: string[];
    stream?: boolean;
    stream_options?: {
        include_usage?: boolean;
    };
}
type OpenAIChatMessage = {
    role: 'system';
    content: string;
} | {
    role: 'user';
    content: string;
} | {
    role: 'assistant';
    content: string | null;
    tool_calls?: Array<{
        id: string;
        type: 'function';
        function: {
            name: string;
            arguments: string;
        };
    }>;
} | {
    role: 'tool';
    content: string;
    tool_call_id: string;
};
interface OpenAIChatTool {
    type: 'function';
    function: {
        name: string;
        description?: string;
        parameters: Record<string, unknown>;
    };
}
interface OpenAIChatCompletion {
    choices: Array<{
        message: {
            role: string;
            content: string | null;
            tool_calls?: Array<{
                id: string;
                type: 'function';
                function: {
                    name: string;
                    arguments: string;
                };
            }>;
        };
        finish_reason: string;
    }>;
    usage?: {
        prompt_tokens: number;
        completion_tokens: number;
        total_tokens: number;
    };
}
interface OpenAIChatStream {
    [Symbol.asyncIterator](): AsyncIterator<OpenAIChatStreamChunk>;
}
interface OpenAIChatStreamChunk {
    choices: Array<{
        delta: {
            role?: string;
            content?: string | null;
            tool_calls?: Array<{
                index: number;
                id?: string;
                type?: 'function';
                function?: {
                    name?: string;
                    arguments?: string;
                };
            }>;
        };
        finish_reason: string | null;
    }>;
    usage?: {
        prompt_tokens: number;
        completion_tokens: number;
        total_tokens: number;
    } | null;
}
interface OpenAIResponsesParams {
    model: string;
    input: OpenAIResponsesInput[];
    tools?: OpenAIResponsesTool[];
    tool_choice?: string | {
        type: 'function';
        name: string;
    };
    temperature?: number;
    max_output_tokens?: number;
    stream?: boolean;
    instructions?: string;
}
type OpenAIResponsesInput = {
    role: 'developer';
    content: string;
} | {
    role: 'user';
    content: string;
} | {
    role: 'assistant';
    content: string;
} | {
    type: 'function_call';
    call_id: string;
    name: string;
    arguments: string;
} | {
    type: 'function_call_output';
    call_id: string;
    output: string;
};
interface OpenAIResponsesTool {
    type: 'function';
    name: string;
    description?: string;
    parameters: Record<string, unknown>;
}
interface OpenAIResponseOutputItem {
    type: string;
    role?: string;
    content?: Array<{
        type: string;
        text: string;
    }>;
    id?: string;
    call_id?: string;
    name?: string;
    arguments?: string;
    status?: string;
}
interface OpenAIResponseObject {
    id: string;
    output: OpenAIResponseOutputItem[];
    status: string;
    incomplete_details?: {
        reason: string;
    } | null;
    usage?: {
        input_tokens: number;
        output_tokens: number;
        total_tokens: number;
    };
}
interface OpenAIResponsesStream {
    [Symbol.asyncIterator](): AsyncIterator<OpenAIResponsesStreamEvent>;
}
interface OpenAIResponsesStreamEvent {
    type: string;
    delta?: string;
    output_index?: number;
    name?: string;
    call_id?: string;
    arguments?: string;
    item?: OpenAIResponseOutputItem;
    response?: OpenAIResponseObject;
}
/**
 * Configuration for the OpenAI adapter.
 * Provide either `apiKey` (adapter creates client) or `client` (pre-configured).
 *
 * The `api` option selects which OpenAI API to use:
 * - `'chat'` (default): Chat Completions API
 * - `'responses'`: Responses API
 */
export type OpenAIAdapterConfig = (BaseLlmAdapterConfig & {
    client?: never;
    api?: OpenAIApiMode;
}) | {
    model: string;
    client: OpenAIClient;
    api?: OpenAIApiMode;
    temperature?: number;
    maxTokens?: number;
    timeout?: number;
    maxRetries?: number;
};
export declare class OpenAIAdapter extends BaseLlmAdapter implements AgentLlmAdapter {
    private client;
    private readonly providedClient;
    private readonly apiMode;
    constructor(config: OpenAIAdapterConfig);
    private getClient;
    completion(prompt: AgentPrompt, tools?: AgentToolDefinition[], options?: AgentCompletionOptions): Promise<AgentCompletion>;
    streamCompletion(prompt: AgentPrompt, tools?: AgentToolDefinition[], options?: AgentCompletionOptions): AsyncGenerator<AgentCompletionChunk>;
    private completionViaChat;
    private streamViaChat;
    private completionViaResponses;
    private streamViaResponses;
    private buildChatParams;
    private buildChatMessages;
    private formatChatTools;
    private parseChatResponse;
    private mapChatFinishReason;
    private buildResponsesParams;
    private buildResponsesInput;
    private formatResponsesTools;
    private parseResponsesResponse;
    private mapResponsesStatus;
    protected formatMessage(message: AgentMessage): unknown;
    protected formatTools(tools: AgentToolDefinition[]): unknown[];
    protected parseResponse(response: unknown): AgentCompletion;
    private buildToolCallsFromMap;
    private wrapError;
}
export {};
//# sourceMappingURL=openai.adapter.d.ts.map