import { type ServerResponse } from 'node:http';
import type { OpenAIMessage } from './protocol.js';
export type PiCompleteResolver = (name: string) => Promise<any>;
export declare function resolvePiComplete(importer?: PiCompleteResolver): Promise<{
    fn: any;
    source: string;
}>;
type Usage = {
    input: number;
    output: number;
    totalTokens?: number;
};
type AssistantMessage = {
    role?: 'assistant';
    content?: any[];
    responseId?: string;
    timestamp: number;
    responseModel?: string;
    model?: string;
    usage?: Usage;
    stopReason?: 'stop' | 'toolUse' | 'length' | 'error' | 'aborted' | string;
    errorMessage?: string;
};
export interface PiModelProxyOptions {
    model: any;
    apiKey?: string;
    headers?: Record<string, string>;
    signal?: AbortSignal;
    timeoutMs?: number;
    completeFn?: any;
    completeSource?: string;
    completeImporter?: PiCompleteResolver;
    pi?: any;
    onEvent?: (event: any) => void;
}
export declare class UpstreamModelError extends Error {
    constructor(message: string);
}
export declare class AbortRequestError extends Error {
    constructor(message?: string);
}
export declare function abortError(): AbortRequestError;
export declare function zeroUsage(): Usage;
export declare function sanitizeErrorMessage(e: unknown): string;
export declare const sanitizeError: typeof sanitizeErrorMessage;
export declare function resolvePiModel(ctx: any): any;
declare function openAIChatToPiContext(request: any): any;
declare function toPiContext(messages: OpenAIMessage[] | undefined, tools: any[] | undefined): any;
declare function normalizeToolArguments(value: unknown): Record<string, unknown>;
declare function toOpenAIToolCalls(blocks: any[]): {
    id: any;
    type: string;
    function: {
        name: string;
        arguments: string;
    };
}[];
export declare function toOpenAIFinishReason(reason: AssistantMessage['stopReason']): string;
export declare function toOpenAIUsage(usage: Usage): Record<string, number>;
export declare function piAssistantToOpenAIResponse(message: AssistantMessage): Record<string, unknown>;
export declare function writeOpenAIStream(res: ServerResponse, message: AssistantMessage): void;
export declare function writeJson(res: ServerResponse, status: number, body: unknown): void;
export declare function writeProxyError(res: ServerResponse, error: unknown): void;
export declare class PiModelProxy {
    private readonly options;
    private server?;
    completionSource?: string;
    constructor(options: PiModelProxyOptions);
    start(): Promise<string>;
    stop(): Promise<void>;
    private handle;
    private complete;
}
export declare function startModelProxyFromPiModel(options: PiModelProxyOptions): Promise<{
    url: string;
    close: () => Promise<void>;
    proxy: PiModelProxy;
    readonly completionSource: string | undefined;
}>;
export declare const startModelProxy: typeof startModelProxyFromPiModel;
export declare const _test: {
    toPiContext: typeof toPiContext;
    openAIChatToPiContext: typeof openAIChatToPiContext;
    piAssistantToOpenAIResponse: typeof piAssistantToOpenAIResponse;
    writeOpenAIStream: typeof writeOpenAIStream;
    sanitizeErrorMessage: typeof sanitizeErrorMessage;
    toOpenAIToolCalls: typeof toOpenAIToolCalls;
    normalizeToolArguments: typeof normalizeToolArguments;
};
export {};