/**
 * Headroom OpenClaw Plugin — register ContextEngine + CCR retrieval tool.
 *
 * Usage:
 *   openclaw plugins install @headroom-ai/openclaw
 *
 * Configuration (in ~/.openclaw/config.json or ~/.clawdbot/clawdbot.json):
 *   {
 *     "plugins": {
 *       "slots": { "contextEngine": "headroom" },
 *       "entries": { "headroom": { "enabled": true } }
 *     }
 *   }
 */
declare function headroomPlugin(api: any): void;

/**
 * Manages the Headroom proxy process lifecycle.
 *
 * - Detects if a proxy is already running (e.g., user has `headroom proxy` for Claude Code)
 * - If not, spawns one as a child process with auto-assigned port
 * - Health checks, restart on crash, graceful shutdown
 */
interface ProxyManagerConfig {
    proxyUrl?: string;
    pythonPath?: string;
    autoStart?: boolean;
    proxyPort?: number;
}
interface ProxyManagerLogger {
    info(message: string): void;
    warn(message: string): void;
    error(message: string): void;
    debug(message: string): void;
}
declare class ProxyManager {
    private config;
    private logger;
    private process;
    private proxyUrl;
    private weStartedIt;
    private restartCount;
    private healthInterval;
    private disposed;
    constructor(config?: ProxyManagerConfig, logger?: ProxyManagerLogger);
    /**
     * Ensure a proxy is available. Returns the URL.
     *
     * 1. If proxyUrl is configured, use it
     * 2. Check if proxy is already running on default port
     * 3. If autoStart, spawn one
     */
    start(): Promise<string>;
    /**
     * Spawn the headroom proxy as a child process.
     */
    private spawnProxy;
    /**
     * Stop the proxy if we started it.
     */
    stop(): Promise<void>;
    getUrl(): string | null;
    private healthCheck;
    private waitForHealthy;
    private startHealthMonitor;
    private handleCrash;
    private findPython;
    private checkHeadroomInstalled;
    private findFreePort;
}

/**
 * HeadroomContextEngine — ContextEngine implementation for OpenClaw.
 *
 * Compresses tool outputs and conversation context using the Headroom proxy.
 * Zero LLM calls — all compression is algorithmic (SmartCrusher, ContentRouter, etc.)
 */

interface HeadroomEngineConfig extends ProxyManagerConfig {
    enabled?: boolean;
}
declare class HeadroomContextEngine {
    readonly info: {
        id: string;
        name: string;
        version: string;
        ownsCompaction: boolean;
    };
    private proxyManager;
    private proxyUrl;
    private config;
    private logger;
    private stats;
    constructor(config?: HeadroomEngineConfig, logger?: ProxyManagerLogger);
    bootstrap(params: {
        sessionId: string;
        sessionKey?: string;
        sessionFile: string;
    }): Promise<{
        bootstrapped: boolean;
        reason?: string;
    }>;
    ingest(params: {
        sessionId: string;
        message: any;
        isHeartbeat?: boolean;
    }): Promise<{
        ingested: boolean;
    }>;
    ingestBatch?(params: {
        sessionId: string;
        messages: any[];
        isHeartbeat?: boolean;
    }): Promise<{
        ingestedCount: number;
    }>;
    /**
     * Assemble context for the model — THE CORE HOOK.
     *
     * Converts AgentMessage[] → OpenAI format → compress() → AgentMessage[]
     */
    assemble(params: {
        sessionId: string;
        messages: any[];
        tokenBudget?: number;
        model?: string;
        prompt?: string;
    }): Promise<{
        messages: any[];
        estimatedTokens: number;
        systemPromptAddition?: string;
    }>;
    /**
     * Compact context — zero-cost alternative to LLM summarization.
     *
     * Calls compress() with the token budget, which triggers:
     * - SmartCrusher: aggressive JSON compression (70-90% on tool outputs)
     * - Kompress: ModernBERT text compression (40-60% on assistant text)
     * - RollingWindow: drops oldest messages if still over budget
     * - CCR: stores originals for retrieval via headroom_retrieve tool
     *
     * Zero LLM calls. All algorithmic.
     */
    compact(params: {
        sessionId: string;
        sessionFile: string;
        tokenBudget?: number;
        force?: boolean;
        runtimeContext?: any;
    }): Promise<{
        ok: boolean;
        compacted: boolean;
        reason?: string;
        result?: {
            tokensBefore: number;
            tokensAfter?: number;
        };
    }>;
    afterTurn?(params: {
        sessionId: string;
        messages: any[];
        prePromptMessageCount: number;
        isHeartbeat?: boolean;
    }): Promise<void>;
    prepareSubagentSpawn?(params: {
        parentSessionKey: string;
        childSessionKey: string;
        ttlMs?: number;
    }): Promise<{
        rollback: () => Promise<void>;
    } | undefined>;
    onSubagentEnded?(params: {
        childSessionKey: string;
        reason: string;
    }): Promise<void>;
    dispose(): Promise<void>;
    getStats(): {
        totalCompressions: number;
        totalTokensSaved: number;
        totalTokensBefore: number;
        compactions: number;
    };
    getProxyUrl(): string | null;
}

/**
 * Convert between OpenClaw's AgentMessage format and OpenAI message format.
 *
 * AgentMessage uses:
 *   role: "user" | "assistant" | "toolResult"
 *   content: string | ContentBlock[]
 *
 * OpenAI uses:
 *   role: "user" | "assistant" | "system" | "tool"
 *   content: string
 *   tool_calls?: ToolCall[]
 *   tool_call_id?: string
 */
interface OpenAIMessage {
    role: string;
    content: string | null;
    tool_calls?: any[];
    tool_call_id?: string;
    name?: string;
}
/**
 * Convert AgentMessage[] to OpenAI message format for compression.
 */
declare function agentToOpenAI(messages: any[]): OpenAIMessage[];
/**
 * Convert compressed OpenAI messages back to AgentMessage format.
 */
declare function openAIToAgent(messages: OpenAIMessage[]): any[];

/**
 * CCR (Compress-Cache-Retrieve) tool for OpenClaw.
 *
 * Allows the agent to retrieve original uncompressed content
 * from the Headroom proxy's compression store.
 */
interface RetrieveToolConfig {
    proxyUrl: string;
}
declare function createHeadroomRetrieveTool(config: RetrieveToolConfig): {
    name: string;
    description: string;
    parameters: {
        type: "object";
        properties: {
            hash: {
                type: string;
                description: string;
            };
            query: {
                type: string;
                description: string;
            };
        };
        required: string[];
    };
    execute: (args: {
        hash: string;
        query?: string;
    }) => Promise<string>;
};

export { HeadroomContextEngine, ProxyManager, agentToOpenAI, createHeadroomRetrieveTool, headroomPlugin as default, openAIToAgent };