import type { ONIStreamEvent, CustomStreamEvent, MessageStreamEvent } from "./types.js";
export interface TokenStreamEvent {
    event: "token";
    node: string;
    token: string;
    delta: string;
    timestamp: number;
    agentId?: string;
}
type TokenHandler = (token: string) => void;
/**
 * Scope a token handler to the current async execution context.
 * Parallel nodes each get their own handler — no global state conflicts.
 */
export declare function _withTokenHandler<T>(handler: TokenHandler, fn: () => Promise<T>): Promise<T>;
/**
 * Emit a token from inside a node. Call this for each token
 * received from your streaming LLM SDK.
 *
 * @example
 * addNode("agent", async (state) => {
 *   let fullText = "";
 *   for await (const chunk of llm.stream(messages)) {
 *     emitToken(chunk.delta);
 *     fullText += chunk.delta;
 *   }
 *   return { messages: [aiMessage(fullText)] };
 * });
 */
export declare function emitToken(token: string): void;
export declare class TokenStreamWriter {
    private queue;
    private waiters;
    private done;
    push(token: string): void;
    end(): void;
    [Symbol.asyncIterator](): AsyncGenerator<string>;
}
export type AnyStreamEvent<S> = (ONIStreamEvent<S> & {
    event: ONIStreamEvent<S>["event"];
}) | TokenStreamEvent | CustomStreamEvent | MessageStreamEvent;
export declare class StreamWriterImpl {
    private readonly onCustom;
    private readonly onToken;
    private readonly onMessage;
    private readonly node;
    private readonly step;
    private readonly messageId;
    private readonly agentId?;
    private _accumulated;
    constructor(onCustom: (evt: CustomStreamEvent) => void, onToken: (token: string) => void, onMessage: (evt: MessageStreamEvent) => void, node: string, step: number, messageId: string, agentId?: string | undefined);
    emit(name: string, data: unknown): void;
    token(token: string): void;
    /** Called by Pregel after node completes to emit the complete message */
    _complete(): MessageStreamEvent | null;
    get accumulated(): string;
}
export type BackpressureStrategy = "drop-oldest" | "error";
export declare class BoundedBuffer<T> {
    private readonly capacity;
    private readonly strategy;
    private ring;
    private head;
    private tail;
    private _size;
    constructor(capacity: number, strategy: BackpressureStrategy);
    push(item: T): void;
    drain(): T[];
    get size(): number;
}
export {};
//# sourceMappingURL=streaming.d.ts.map