import { Effect, Option } from "effect";
import { Chat, Prompt, Tokenizer } from "effect/unstable/ai";
import { AgentError } from "./agent-event.js";
import { Compaction, type Result as CompactionResult, type Usage } from "../turn/compaction.js";
import { type CompactionCommit, type Event as ModelTelemetryEvent } from "../model/model-telemetry.js";
import type { RunError, RunOptions } from "./agent.js";
import type { AgentRunState } from "./agent-run-state.js";
import { SessionConflict, SessionStore, type Entry, type SessionStoreError } from "../context/session.js";
import { type DriverInterpreter } from "../durable/driver-interpreter.js";
import type { MemoryError } from "../context/memory.js";
import type { SkillSourceError } from "../context/skill-source.js";
type CompactionContext = {
    readonly activeSession: Option.Option<typeof SessionStore.Service>;
    readonly sessionService: Option.Option<typeof SessionStore.Service>;
    readonly sessionId: string;
    readonly sessionOwnerToken: string | undefined;
    readonly sessionAppendOptions: (expectedLeafId: string | null) => {
        readonly expectedLeafId: string | null;
        readonly ownerToken?: string;
    };
    readonly chat: Chat.Service;
    readonly system: string | undefined;
    readonly persisted: Chat.Persisted | undefined;
    readonly options: RunOptions;
    readonly state: AgentRunState;
    readonly compactionService: Option.Option<typeof Compaction.Service>;
    readonly tokenizerService: Option.Option<typeof Tokenizer.Tokenizer.Service>;
    readonly deliverPending: Effect.Effect<void, import("../model/model-telemetry.js").DeliveryFailed>;
    readonly savePersisted: (turn: number) => Effect.Effect<void, AgentError>;
    readonly undeliveredTelemetry: Array<ModelTelemetryEvent>;
    readonly emitTelemetry: (event: import("../model/model-telemetry.js").EventPayload) => Effect.Effect<void>;
    readonly prepareTelemetry: (event: import("../model/model-telemetry.js").EventPayload) => ModelTelemetryEvent;
    readonly publishTelemetry: (event: ModelTelemetryEvent) => void;
    readonly errorMessage: (error: unknown) => string;
    readonly agent: {
        readonly name: string;
    };
    readonly memoryRuntime: unknown | undefined;
    readonly memoryError: (turn: number, error: MemoryError) => AgentError;
    readonly skillError: (turn: number, error: SkillSourceError) => AgentError;
    readonly compactionError: (turn: number, error: import("../turn/compaction.js").CompactionError) => AgentError;
    readonly sessionError: (turn: number, error: SessionStoreError | SessionConflict) => AgentError;
};
export declare const makeCompactionRuntime: (context: CompactionContext) => {
    preparePrompt: (turn: number, prompt: Prompt.Prompt, overflow: boolean) => Effect.Effect<{
        prompt: Prompt.Prompt;
        changed: boolean;
    }, never, never> | Effect.Effect<{
        prompt: Prompt.Prompt;
        changed: boolean;
    }, RunError, DriverInterpreter | import("effect/unstable/ai/LanguageModel").LanguageModel>;
    applyCompactionResult: (turn: number, result: CompactionResult, parentId: string | null, applicationIdentity: string, commitData?: Omit<CompactionCommit, "checkpointId" | "summaryModelCallId">, onCommitted?: () => void) => Effect.Effect<void, RunError, DriverInterpreter>;
    compactionUsage: (turn: number, history: Prompt.Prompt, prompt: Prompt.Prompt) => Effect.Effect<Usage, AgentError>;
    countTokens: (turn: number, prompt: Prompt.Prompt) => Effect.Effect<number, AgentError>;
    syncSession: (turn: number, transcript: Prompt.Prompt) => Effect.Effect<ReadonlyArray<Entry>, RunError, DriverInterpreter>;
};
export {};