import type { MastraDBMessage, MessageList } from '@mastra/core/agent';
import type { Processor, ProcessInputStepArgs, ProcessOutputResultArgs } from '@mastra/core/processors';
import type { ObservationalMemoryRecord } from '@mastra/core/storage';
import type { ObservationalMemory } from './observational-memory.js';
/** Subset of Memory that the processor needs — avoids circular imports. */
export interface MemoryContextProvider {
    getContext(opts: {
        threadId: string;
        resourceId?: string;
    }): Promise<{
        systemMessage: string | undefined;
        messages: MastraDBMessage[];
        hasObservations: boolean;
        omRecord: ObservationalMemoryRecord | null;
        continuationMessage: MastraDBMessage | undefined;
        otherThreadsContext: string | undefined;
    }>;
    /** Raw message upsert — persist sealed messages to storage without embedding or working memory processing. */
    persistMessages(messages: MastraDBMessage[]): Promise<void>;
}
export declare class ObservationalMemoryProcessor implements Processor<'observational-memory'> {
    readonly id: "observational-memory";
    readonly name = "Observational Memory";
    /** The underlying ObservationalMemory engine. */
    readonly engine: ObservationalMemory;
    /** Memory instance for loading context. */
    private readonly memory;
    /** Whether temporal-gap reminder markers should be inserted. */
    private readonly temporalMarkers;
    /** Active turn — created on first processInputStep, ended on processOutputResult. */
    private turn?;
    constructor(engine: ObservationalMemory, memory: MemoryContextProvider, options?: {
        temporalMarkers?: boolean;
    });
    processInputStep(args: ProcessInputStepArgs): Promise<MessageList | MastraDBMessage[]>;
    processOutputResult(args: ProcessOutputResultArgs): Promise<MessageList | MastraDBMessage[]>;
    get config(): {
        scope: "resource" | "thread";
        retrieval: boolean;
        observation: {
            messageTokens: number | import("./types").ThresholdRange;
            previousObserverTokens: number | false | undefined;
        };
        reflection: {
            observationTokens: number | import("./types").ThresholdRange;
        };
    };
    waitForBuffering(threadId: string | null | undefined, resourceId: string | null | undefined, timeoutMs?: number): Promise<void>;
    getResolvedConfig(requestContext?: any): Promise<{
        scope: "resource" | "thread";
        observation: {
            messageTokens: number | import("./types").ThresholdRange;
            model: string;
            previousObserverTokens: number | false | undefined;
            routing?: Array<{
                upTo: number;
                model: string;
            }>;
        };
        reflection: {
            observationTokens: number | import("./types").ThresholdRange;
            model: string;
            routing?: Array<{
                upTo: number;
                model: string;
            }>;
        };
    }>;
}
//# sourceMappingURL=processor.d.ts.map