import { type Memory, type MemoryConfigBase, type MemoryStats, type MinimalMessage } from "./memory-interface.js";
type BasicMemoryType = "conversation" | "buffer";
declare abstract class BasicMemoryStore<M extends MinimalMessage> implements Memory<M> {
    protected messages: M[];
    protected abstract readonly memoryType: BasicMemoryType;
    protected abstract readonly spanPrefix: string;
    abstract add(message: M): Promise<void>;
    getMessages(): Promise<M[]>;
    clear(): Promise<void>;
    getStats(): Promise<MemoryStats>;
}
/** Implement conversation memory. */
export declare class ConversationMemory<M extends MinimalMessage = MinimalMessage> extends BasicMemoryStore<M> {
    private config;
    protected readonly memoryType: "conversation";
    protected readonly spanPrefix = "agent.memory.conversation";
    constructor(config: MemoryConfigBase);
    add(message: M): Promise<void>;
    private trimToTokenLimit;
}
/** Implement buffer memory. */
export declare class BufferMemory<M extends MinimalMessage = MinimalMessage> extends BasicMemoryStore<M> {
    protected readonly memoryType: "buffer";
    protected readonly spanPrefix = "agent.memory.buffer";
    private bufferSize;
    constructor(config: MemoryConfigBase);
    add(message: M): Promise<void>;
}
/** Implement summary memory. */
export declare class SummaryMemory<M extends MinimalMessage = MinimalMessage> implements Memory<M> {
    private config;
    private messages;
    private summary;
    private summaryThreshold;
    private summaryMaxChars;
    private maxTokens?;
    constructor(config: MemoryConfigBase);
    add(message: M): Promise<void>;
    getMessages(): Promise<M[]>;
    clear(): Promise<void>;
    getStats(): Promise<MemoryStats>;
    private summarizeOldMessages;
    private appendToSummary;
    private enforceTokenLimit;
    private totalTextChars;
    private boundSummary;
}
/**
 * No-op memory.
 *
 * Holds nothing and never persists. Used when an agent has no `memory` config
 * (the documented stateless default) or when `memory.enabled === false`. Every
 * `stream()` / `generate()` call then runs in isolation on just its own input,
 * which is what makes concurrent fan-out on a shared agent instance safe: runs
 * cannot interleave into a shared conversation. Multi-step tool loops are
 * unaffected: in-run continuity is driven by the loop's local message array,
 * not by this store.
 */
export declare class NoMemory<M extends MinimalMessage = MinimalMessage> implements Memory<M> {
    add(_message: M): Promise<void>;
    getMessages(): Promise<M[]>;
    clear(): Promise<void>;
    getStats(): Promise<MemoryStats>;
}
/** Create memory. */
export declare function createMemory<M extends MinimalMessage = MinimalMessage>(config: MemoryConfigBase): Memory<M>;
/**
 * Resolve the memory store for an agent runtime.
 *
 * Agents are stateless by default: with no `memory` config (or `enabled: false`)
 * the runtime gets a {@link NoMemory} store so calls never share conversation
 * history. A provided config opts in to cross-call persistence.
 */
export declare function createAgentMemory<M extends MinimalMessage = MinimalMessage>(config?: MemoryConfigBase): Memory<M>;
export {};
//# sourceMappingURL=memory.d.ts.map