/**
 * Tiny headless internal-agent-call seam for Observational Memory.
 *
 * The Observer and Reflector each need a single, tool-less LLM round-trip:
 * "here is some text, compress it". Rather than touch `production-agent.ts`,
 * this reuses the SAME pattern the evals lane built — resolve a provider-
 * agnostic engine + model from the registry (NEVER hardcode a model) and drive
 * one `engine.stream()` to completion, collecting the text. It mirrors the
 * `analyzeContext().judge` helper in `eval/agent-runner.ts`.
 *
 * Everything is injectable so tests can supply a fake engine and assert no real
 * model is ever called.
 */
import type { AgentEngine } from "../engine/types.js";
export interface InternalAgentRunOptions {
    systemPrompt: string;
    prompt: string;
    maxOutputTokens?: number;
    /** Pre-resolved engine; resolved from the registry when omitted. */
    engine?: AgentEngine;
    /** Pre-resolved model; resolved from the engine's stored/default when omitted. */
    model?: string;
    timeoutMs?: number;
    signal?: AbortSignal;
}
/**
 * Run one tool-less internal agent call and return the collected text.
 *
 * Resolution goes through `resolveEngine` / `getStoredModelForEngine` /
 * `normalizeModelForEngine` — identical to the eval runner — so the compactor
 * uses whatever provider/model the app is configured for. No model is ever
 * hardcoded here.
 */
export declare function runInternalAgentCall(options: InternalAgentRunOptions): Promise<string>;
/** The shape the Observer/Reflector depend on — injectable for tests. */
export type InternalAgentRunFn = (options: InternalAgentRunOptions) => Promise<string>;
//# sourceMappingURL=internal-run.d.ts.map