import type { Reasoning } from "@velum-labs/routekit-contracts/protocol-ir";
import { type RouteKitPlatform } from "@velum-labs/routekit-runtime/effect";
import { Effect } from "effect";
import type { HttpClient } from "effect/unstable/http";
import { type Backend, type BackendPorts, type BackendRequest, type BackendRequestOptions } from "./backend.js";
import type { ProviderRecord } from "./protocol.js";
export declare function invalidReasoningControlResponse(message: string, metadata?: boolean, path?: string): Response;
export type ChatMessage = {
    role?: string;
    content?: unknown;
    reasoning?: string;
    reasoning_details?: Reasoning[];
    tool_calls?: Array<{
        id?: string;
        index?: number;
        function?: {
            name?: string;
            arguments?: string;
        };
    }>;
    tool_call_id?: string;
};
export type ChatBody = {
    [key: string]: unknown;
    model?: string;
    messages?: ChatMessage[];
    tools?: Array<{
        type?: string;
        function?: Record<string, unknown>;
    }>;
    tool_choice?: unknown;
    parallel_tool_calls?: boolean;
    stream?: boolean;
    max_tokens?: number;
    max_completion_tokens?: number;
    temperature?: number;
    top_p?: number;
    top_k?: number;
    reasoning_effort?: string;
    response_format?: {
        type?: string;
        json_schema?: {
            name?: string;
            description?: string;
            schema?: unknown;
            strict?: boolean;
        };
    };
};
export type ProviderBackendOptions = {
    baseUrl: string;
    apiKey: string;
    defaultModel?: string;
    headers?: Record<string, string>;
    transport?: ProviderTransport;
    forceStream?: boolean;
    omitSampling?: boolean;
};
export type ProviderTransport = (url: string, init: RequestInit, options?: BackendRequestOptions) => Effect.Effect<Response, Error, RouteKitPlatform>;
export declare function defaultProviderTransport(url: string, init: RequestInit): Effect.Effect<Response, Error, HttpClient.HttpClient>;
export declare function providerTransport(transport: ProviderTransport, url: string, init: RequestInit, options?: BackendRequestOptions): BackendRequest;
export declare abstract class HttpProviderBackend implements Backend {
    readonly ports: BackendPorts;
    readonly defaultModel: string | undefined;
    readonly baseUrl: string;
    readonly apiKey: string;
    readonly extraHeaders: Record<string, string>;
    readonly transport: ProviderTransport;
    constructor(options: ProviderBackendOptions);
    reasoningWireShape(_model: string): string | undefined;
    listModelIds(): readonly string[];
    servesModel(model: string): boolean;
    models(): BackendRequest;
    embeddings(): BackendRequest;
    abstract chat(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): BackendRequest;
}
export declare function bodyRecord(body: unknown): ChatBody;
export declare function textContent(content: unknown): string;
export declare function chatCompletion(model: string, message: Record<string, unknown>, usage?: unknown, finishReason?: string, choiceMetadata?: Record<string, unknown>): unknown;
export declare function normalizedOpenAiUsage(usage: unknown): Record<string, unknown> | undefined;
export declare function mapSse(response: Response, mapper: (event: string, data: ProviderRecord) => readonly unknown[], decode: (data: unknown, event: string) => ProviderRecord): Response;