import type { TSchema } from "typebox";
export type Api = string;
export type CacheRetention = "none" | "short" | "long";
export type Transport = "sse" | "websocket" | "websocket-cached" | "auto";
export type ThinkingLevel = "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
export type ModelThinkingLevel = "off" | ThinkingLevel;
export type MaybePromise<T> = T | Promise<T>;
export interface ProviderResponse {
    status: number;
    headers: Record<string, string>;
}
export interface ThinkingBudgets {
    minimal?: number;
    low?: number;
    medium?: number;
    high?: number;
    max?: number;
}
export interface DiagnosticErrorInfo {
    name?: string;
    message: string;
    stack?: string;
    code?: string | number;
}
export interface AssistantMessageDiagnostic {
    type: string;
    timestamp: number;
    error?: DiagnosticErrorInfo;
    details?: Record<string, unknown>;
}
export interface SimpleStreamOptions {
    temperature?: number;
    maxTokens?: number;
    signal?: AbortSignal;
    apiKey?: string;
    transport?: Transport;
    cacheRetention?: CacheRetention;
    sessionId?: string;
    onPayload?: (payload: unknown, model: Model) => MaybePromise<unknown>;
    onResponse?: (response: ProviderResponse, model: Model) => void | Promise<void>;
    headers?: Record<string, string>;
    timeoutMs?: number;
    maxRetries?: number;
    maxRetryDelayMs?: number;
    metadata?: Record<string, unknown>;
    reasoning?: ThinkingLevel;
    thinkingBudgets?: ThinkingBudgets;
}
export interface TextContent {
    type: "text";
    text: string;
    textSignature?: string;
}
export interface ThinkingContent {
    type: "thinking";
    thinking: string;
    thinkingSignature?: string;
    redacted?: boolean;
}
export interface ImageContent {
    type: "image";
    data: string;
    mimeType: string;
}
export interface ToolCall {
    type: "toolCall";
    id: string;
    name: string;
    arguments: Record<string, unknown>;
    thoughtSignature?: string;
    executionMode?: "sequential" | "parallel";
}
export interface Usage {
    input: number;
    output: number;
    cacheRead: number;
    cacheWrite: number;
    totalTokens: number;
    cost: {
        input: number;
        output: number;
        cacheRead: number;
        cacheWrite: number;
        total: number;
    };
}
export type StopReason = "stop" | "length" | "toolUse" | "aborted" | "error";
export interface UserMessage {
    role: "user";
    content: string | (TextContent | ImageContent)[];
    timestamp: number;
}
export interface AssistantMessage {
    role: "assistant";
    content: (TextContent | ThinkingContent | ToolCall)[];
    api: Api;
    provider: string;
    model: string;
    responseModel?: string;
    responseId?: string;
    diagnostics?: AssistantMessageDiagnostic[];
    stopReason: StopReason;
    errorMessage?: string;
    timestamp: number;
    usage: Usage;
}
export interface ToolResultMessage {
    role: "toolResult";
    toolCallId: string;
    toolName: string;
    content: (TextContent | ImageContent)[];
    isError: boolean;
    details?: unknown;
    timestamp: number;
}
export type Message = UserMessage | AssistantMessage | ToolResultMessage;
export interface Context {
    systemPrompt?: string;
    messages: Message[];
    tools?: Tool[];
}
export interface Model<TApi extends Api = Api> {
    id: string;
    name: string;
    api: TApi;
    provider: string;
    baseUrl: string;
    input: ("text" | "image")[];
    reasoning: boolean;
    thinkingLevelMap?: Partial<Record<ModelThinkingLevel, string | null>>;
    contextWindow: number;
    maxTokens: number;
    cost: {
        input: number;
        output: number;
        cacheRead: number;
        cacheWrite: number;
    };
    headers?: Record<string, string>;
    compat?: any;
}
export interface Tool<TParameters extends TSchema = TSchema> {
    name: string;
    description: string;
    parameters: TParameters;
}
export type AssistantMessageEvent = {
    type: "start";
    partial: AssistantMessage;
} | {
    type: "text_start";
    contentIndex: number;
    partial: AssistantMessage;
} | {
    type: "text_delta";
    contentIndex: number;
    delta: string;
    partial: AssistantMessage;
} | {
    type: "text_end";
    contentIndex: number;
    content: string;
    partial: AssistantMessage;
} | {
    type: "thinking_start";
    contentIndex: number;
    partial: AssistantMessage;
} | {
    type: "thinking_delta";
    contentIndex: number;
    delta: string;
    partial: AssistantMessage;
} | {
    type: "thinking_end";
    contentIndex: number;
    content: string;
    partial: AssistantMessage;
} | {
    type: "toolcall_start";
    contentIndex: number;
    partial: AssistantMessage;
} | {
    type: "toolcall_delta";
    contentIndex: number;
    delta: string;
    partial: AssistantMessage;
} | {
    type: "toolcall_end";
    contentIndex: number;
    toolCall: ToolCall;
    partial: AssistantMessage;
} | {
    type: "done";
    reason: Extract<StopReason, "stop" | "length" | "toolUse">;
    message: AssistantMessage;
} | {
    type: "error";
    reason: Extract<StopReason, "aborted" | "error">;
    error: AssistantMessage;
};
export declare class EventStream<T, R = T> implements AsyncIterable<T> {
    private readonly isComplete;
    private readonly extractResult;
    private queue;
    private waiting;
    private done;
    private finalResultPromise;
    private resolveFinalResult;
    constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R);
    push(event: T): void;
    end(result?: R): void;
    [Symbol.asyncIterator](): AsyncIterator<T>;
    result(): Promise<R>;
}
export interface AssistantMessageEventStream extends AsyncIterable<AssistantMessageEvent> {
    result(): Promise<AssistantMessage>;
}
export type StreamFn = (model: Model, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream | Promise<AssistantMessageEventStream>;
export type CompleteSimpleFn = (model: Model, context: Pick<Context, "systemPrompt" | "messages">, options?: SimpleStreamOptions) => Promise<AssistantMessage>;
export type ValidateToolArgumentsFn = (tool: Tool, toolCall: ToolCall) => unknown;