import type { IncomingMessage, ServerResponse } from 'node:http';
export type LocalAgentSseRequest = Pick<IncomingMessage, 'on'>;
export type LocalAgentSseResponse = Pick<ServerResponse, 'on' | 'off' | 'writeHead' | 'write' | 'end' | 'writableEnded'>;
export type LocalAgentSseReader = {
    read: () => Promise<{
        done: boolean;
        value?: Uint8Array;
    }>;
    cancel: () => Promise<unknown>;
    releaseLock: () => void;
};
/** Compatibility names retained for existing OpenClaw and Hermes callers. */
export type OpenClawStreamRequest = LocalAgentSseRequest;
export type OpenClawStreamResponse = LocalAgentSseResponse;
export type OpenClawStreamReader = LocalAgentSseReader;
export declare function writeLocalAgentSseChunk(res: LocalAgentSseResponse, chunk: Uint8Array): Promise<void>;
export type LocalAgentSseFrameAction = {
    /** Forward this frame byte-for-byte to the downstream response. */
    forward: boolean;
    /** Stop at this semantic frame and intentionally drop every later byte. */
    terminal?: boolean;
};
export type LocalAgentSseFrame = {
    event: Record<string, unknown> | null;
    frame: Uint8Array;
    separator: Uint8Array;
};
export type LocalAgentSseStreamResult = {
    terminal: boolean;
    clientGone: boolean;
};
/**
 * Canonical local-agent SSE pump. It owns byte-safe frame splitting, split
 * separators, malformed/oversized frames, backpressure, cancellation, and
 * terminal truncation. Integrations customize only semantic frame policy.
 */
export declare function pipeLocalAgentSseStream(req: LocalAgentSseRequest, res: LocalAgentSseResponse, reader: LocalAgentSseReader, options?: {
    onFrame?: (frame: LocalAgentSseFrame) => LocalAgentSseFrameAction | Promise<LocalAgentSseFrameAction>;
    endResponseOnTerminal?: boolean;
}): Promise<LocalAgentSseStreamResult>;
export type DurableLocalAgentTurn = {
    text: string;
    finalEvent: Record<string, unknown>;
    errorEvent?: Record<string, unknown>;
};
export type DurableLocalAgentTurnCommitResult = {
    ok: true;
    finalEvent: Record<string, unknown>;
} | {
    ok: false;
    errorEvent: Record<string, unknown>;
};
/**
 * One lifecycle owner for local-agent streams whose terminal acknowledgement
 * depends on a durable commit. Deltas pass through immediately. Error/final
 * frames are held, the commit hook is awaited, and only then is the terminal
 * outcome released. A commit failure emits its replacement error and never a
 * final acknowledgement.
 */
export declare function pipeDurableLocalAgentTurnSseStream(req: LocalAgentSseRequest, res: LocalAgentSseResponse, reader: LocalAgentSseReader, commit: (turn: DurableLocalAgentTurn) => Promise<DurableLocalAgentTurnCommitResult>): Promise<LocalAgentSseStreamResult>;
export declare function writeLocalAgentSseEvent(res: LocalAgentSseResponse, event: Record<string, unknown>): Promise<void>;
export declare function pipeOpenClawStream(req: OpenClawStreamRequest, res: OpenClawStreamResponse, reader: OpenClawStreamReader): Promise<void>;
/** Compatibility binding retained while existing callers migrate names. */
export declare const writeOpenClawStreamChunk: typeof writeLocalAgentSseChunk;
//# sourceMappingURL=local-agent-sse.d.ts.map