/**
 * OpenAI-compatible types for the /v1/responses endpoint (the Responses API).
 *
 * These mirror OpenAI's Responses API wire format so agent SDKs that target
 * `client.responses.create` — including multi-turn tool loops with encrypted
 * reasoning replay (`include: ['reasoning.encrypted_content']`) — can point at
 * Verlon as a drop-in. NOTE the shape differences from Chat Completions:
 *   - `input` is an array of typed items, not `messages`
 *   - function tools are FLATTENED (`{ type, name, parameters }`, no nested
 *     `function` object)
 *   - usage uses `input_tokens` / `output_tokens` (not `prompt_tokens`)
 *   - `max_output_tokens`, `instructions`, `reasoning.effort`
 */
export type OpenAIResponsesInputContentPart = {
    type: 'input_text';
    text: string;
} | {
    type: 'input_image';
    image_url: string;
    detail?: 'auto' | 'low' | 'high';
} | {
    type: 'output_text';
    text: string;
} | {
    type: 'refusal';
    refusal: string;
};
export interface OpenAIResponsesInputMessage {
    type?: 'message';
    role: 'user' | 'assistant' | 'system' | 'developer';
    content: string | OpenAIResponsesInputContentPart[];
}
export interface OpenAIResponsesFunctionCallItem {
    type: 'function_call';
    id?: string;
    call_id: string;
    name: string;
    arguments: string;
    status?: 'in_progress' | 'completed' | 'incomplete';
}
export interface OpenAIResponsesFunctionCallOutputItem {
    type: 'function_call_output';
    call_id: string;
    output: string;
}
export interface OpenAIResponsesReasoningItem {
    type: 'reasoning';
    id: string;
    /** Base64 encrypted reasoning; echoed back to replay across tool turns. */
    encrypted_content?: string;
    summary?: Array<{
        type: 'summary_text';
        text: string;
    }>;
    status?: 'in_progress' | 'completed' | 'incomplete';
}
export type OpenAIResponsesInputItem = OpenAIResponsesInputMessage | OpenAIResponsesFunctionCallItem | OpenAIResponsesFunctionCallOutputItem | OpenAIResponsesReasoningItem;
export interface OpenAIResponsesFunctionTool {
    type: 'function';
    name: string;
    description?: string;
    parameters?: Record<string, unknown>;
    strict?: boolean;
}
export type OpenAIResponsesToolChoice = 'auto' | 'required' | 'none' | {
    type: 'function';
    name: string;
};
export interface OpenAIResponsesReasoningConfig {
    effort?: 'low' | 'medium' | 'high';
    summary?: 'auto' | 'concise' | 'detailed';
}
export interface OpenAIResponsesTextConfig {
    format?: {
        type: 'text' | 'json_object' | 'json_schema';
        name?: string;
        schema?: Record<string, unknown>;
        strict?: boolean;
    };
}
export interface OpenAIResponsesRequest {
    model: string;
    input: string | OpenAIResponsesInputItem[];
    instructions?: string;
    tools?: OpenAIResponsesFunctionTool[];
    tool_choice?: OpenAIResponsesToolChoice;
    max_output_tokens?: number;
    temperature?: number;
    top_p?: number;
    reasoning?: OpenAIResponsesReasoningConfig;
    text?: OpenAIResponsesTextConfig;
    parallel_tool_calls?: boolean;
    /** Server-side conversation state — Verlon v1 is stateless (rejects true). */
    store?: boolean;
    previous_response_id?: string;
    include?: string[];
    stream?: boolean;
    metadata?: Record<string, string>;
    /** Verlon extension: gate variables (mirrors the chat-completions extension). */
    vars?: Record<string, unknown>;
}
export interface OpenAIResponsesOutputMessage {
    type: 'message';
    id: string;
    role: 'assistant';
    status?: 'in_progress' | 'completed' | 'incomplete';
    content: Array<{
        type: 'output_text';
        text: string;
        annotations?: unknown[];
    } | {
        type: 'refusal';
        refusal: string;
    }>;
}
export type OpenAIResponsesOutputItem = OpenAIResponsesOutputMessage | OpenAIResponsesFunctionCallItem | OpenAIResponsesReasoningItem;
export interface OpenAIResponsesUsage {
    input_tokens: number;
    output_tokens: number;
    total_tokens: number;
    input_tokens_details?: {
        cached_tokens?: number;
    };
    output_tokens_details?: {
        reasoning_tokens?: number;
    };
}
export interface OpenAIResponsesResponse {
    id: string;
    object: 'response';
    created_at: number;
    model: string;
    status: 'completed' | 'in_progress' | 'failed' | 'incomplete';
    output: OpenAIResponsesOutputItem[];
    /** Convenience aggregation of output_text across message items. */
    output_text?: string;
    usage?: OpenAIResponsesUsage;
    incomplete_details?: {
        reason: string;
    };
    error?: {
        code: string;
        message: string;
    } | null;
    metadata?: Record<string, string>;
}
export type OpenAIResponsesStreamEvent = {
    type: 'response.created';
    response: OpenAIResponsesResponse;
} | {
    type: 'response.in_progress';
    response: OpenAIResponsesResponse;
} | {
    type: 'response.output_item.added';
    output_index: number;
    item: OpenAIResponsesOutputItem;
} | {
    type: 'response.output_text.delta';
    item_id: string;
    output_index: number;
    delta: string;
} | {
    type: 'response.output_text.done';
    item_id: string;
    output_index: number;
    text: string;
} | {
    type: 'response.function_call_arguments.delta';
    item_id: string;
    output_index: number;
    delta: string;
} | {
    type: 'response.function_call_arguments.done';
    item_id: string;
    output_index: number;
    arguments: string;
} | {
    type: 'response.reasoning_summary_text.delta';
    item_id: string;
    output_index: number;
    delta: string;
} | {
    type: 'response.output_item.done';
    output_index: number;
    item: OpenAIResponsesOutputItem;
} | {
    type: 'response.completed';
    response: OpenAIResponsesResponse;
} | {
    type: 'response.failed';
    response: OpenAIResponsesResponse;
} | {
    type: 'response.incomplete';
    response: OpenAIResponsesResponse;
} | {
    type: 'error';
    code?: string;
    message: string;
};
//# sourceMappingURL=openai-responses-format.d.ts.map