import type { ChatResult, MossAgentEvent } from '../core/index.js';
export type HeadlessOutputFormat = 'text' | 'json' | 'stream-json';
export type HeadlessSystemInitEvent = {
    type: 'system';
    subtype: 'init';
    cwd: string;
    tools: string[];
    session_id: string;
    model?: string;
};
export type HeadlessBackgroundProcessSummary = {
    id: string;
    command: string;
    label?: string;
    started_at: number;
    running_for_ms: number;
};
/** Emitted when oneshot exits while background processes are still running. */
export type HeadlessSystemBackgroundStillRunningEvent = {
    type: 'system';
    subtype: 'background_still_running';
    session_id: string;
    message: string;
    processes: HeadlessBackgroundProcessSummary[];
    will_monitor_after_exit: false;
};
export type HeadlessTextBlock = {
    type: 'text';
    text: string;
};
export type HeadlessToolUseBlock = {
    type: 'tool_use';
    id: string;
    name: string;
    input: Record<string, unknown>;
};
export type HeadlessAssistantContentBlock = HeadlessTextBlock | HeadlessToolUseBlock;
export type HeadlessAssistantEvent = {
    type: 'assistant';
    message: {
        type: 'message';
        id: string;
        role: 'assistant';
        model?: string;
        stop_reason: string | null;
        content: HeadlessAssistantContentBlock[];
        usage?: ChatResult['usage'];
    };
    session_id: string;
};
export type HeadlessToolResultBlock = {
    type: 'tool_result';
    tool_use_id: string;
    content: string;
    is_error?: boolean;
    structured_content?: unknown;
};
export type HeadlessUserEvent = {
    type: 'user';
    message: {
        role: 'user';
        content: HeadlessToolResultBlock[];
    };
    session_id: string;
};
export type HeadlessLlmUsageEvent = {
    type: 'llm_usage';
    session_id: string;
    input_tokens: number;
    output_tokens: number;
    cache_read_tokens?: number;
    cache_creation_tokens?: number;
    context_tokens?: number;
};
export type HeadlessCacheMetricsEvent = {
    type: 'cache_metrics';
    session_id: string;
    prompt_cache_enabled: boolean;
    prompt_cache_debug: boolean;
    stable_chars: number;
    dynamic_chars: number;
    eligible: boolean;
    eligibility_reason: string;
    cache_read_tokens: number;
    cache_creation_tokens: number;
};
export type HeadlessResultSubtype = 'success' | 'error_max_turns' | 'error_during_execution';
export type HeadlessResultEvent = {
    type: 'result';
    subtype: HeadlessResultSubtype;
    is_error: boolean;
    result: string;
    duration_ms: number;
    num_turns: number;
    session_id: string;
    total_cost_usd: number | null;
    cost_unavailable: boolean;
    usage?: ChatResult['usage'];
    error?: string;
    structured_output?: unknown;
    /** Present when oneshot exits while background processes are still running. */
    background_still_running?: {
        message: string;
        processes: HeadlessBackgroundProcessSummary[];
        will_monitor_after_exit: false;
    };
};
export type HeadlessStreamEvent = HeadlessSystemInitEvent | HeadlessSystemBackgroundStillRunningEvent | HeadlessAssistantEvent | HeadlessUserEvent | HeadlessLlmUsageEvent | HeadlessCacheMetricsEvent | HeadlessResultEvent;
export interface HeadlessInitInput {
    cwd: string;
    model?: string;
    tools: string[];
    sessionId: string;
}
export interface HeadlessPrintState {
    readonly sessionId: string;
    readonly model?: string;
    readonly startTime: number;
    pendingAssistantText: string;
    pendingToolUses: HeadlessToolUseBlock[];
    assistantSeq: number;
    finalText: string;
    numTurns: number;
    lastError?: string;
    resultEmitted: boolean;
    structuredOutputRequested: boolean;
}
export interface HeadlessPrintStateInput {
    sessionId: string;
    model?: string;
    startTime?: number;
}
export interface HeadlessJsonWriter {
    write(chunk: string): unknown;
}
export declare function createHeadlessPrintState(input: HeadlessPrintStateInput): HeadlessPrintState;
export declare function formatHeadlessInitEvent(input: HeadlessInitInput): HeadlessSystemInitEvent;
export declare function formatHeadlessBackgroundStillRunningEvent(input: {
    sessionId: string;
    message: string;
    processes: ReadonlyArray<{
        id: string;
        command: string;
        label?: string;
        startedAt: number;
    }>;
    now?: number;
}): HeadlessSystemBackgroundStillRunningEvent;
export declare function formatHeadlessStreamEvent(state: HeadlessPrintState, event: MossAgentEvent): HeadlessStreamEvent[];
export declare function formatHeadlessThrownError(state: HeadlessPrintState, error: unknown): HeadlessStreamEvent[];
export declare function isHeadlessResultError(event: HeadlessResultEvent): boolean;
export declare function writeHeadlessJson(writer: HeadlessJsonWriter, event: HeadlessStreamEvent): void;
//# sourceMappingURL=print.d.ts.map