import { Middleware } from "./compose.js";
import type { Ctx, ExecuteOptions, ExecuteResult, ExecuteStreamEvent, ExecuteStreamOptions, Logger, Memory, TokenStream, Tool, ToolRegistry, LLM } from "./types.js";
export type LogLevel = "debug" | "info" | "warn" | "error";
export declare function parseLogLevel(level: string | undefined): LogLevel | undefined;
export declare function createConsoleLogger(opts?: {
    level?: LogLevel;
    timestamps?: boolean;
}): Logger;
export declare const consoleLogger: Logger;
export interface TraceEvent {
    level: LogLevel | "span";
    ts: string;
    args: unknown[];
}
export declare function createTracingLogger(base?: Logger): {
    logger: Logger;
    getTrace: () => TraceEvent[];
    reset: () => void;
};
export interface RedactOptions {
    keys?: string[];
    mask?: string;
    patterns?: RegExp[];
}
export declare function redactSensitive(input: unknown, opts?: RedactOptions): unknown;
export declare function createRedactingLogger(base: Logger, opts?: RedactOptions): Logger;
export declare class InMemoryKV implements Memory {
    private m;
    get<T = unknown>(key: string): Promise<T | undefined>;
    set(key: string, val: unknown): Promise<void>;
    retrieval(index: string): {
        search: (q: string, topK?: number) => Promise<{
            text: string;
            score: number;
        }[]>;
    };
}
export declare class NullStream implements TokenStream {
    write(_t: string): void;
    end(): void;
}
export declare const stdoutStream: TokenStream;
export declare const inputToMessage: Middleware;
export declare function bufferStream(): {
    stream: {
        write: (t: string) => void;
        end: () => void;
    };
    getText: () => string;
};
export declare function getExecutionResult(ctx: Pick<Ctx, "state">): ExecuteResult | undefined;
export declare function getExecutionEvents(ctx: Pick<Ctx, "state">): ExecuteStreamEvent[];
export declare function teeStream(...streams: TokenStream[]): TokenStream;
export declare const executeWith: (options?: ExecuteOptions) => Middleware;
export declare const execute: Middleware;
type ExecuteStreamMiddleware = Middleware & ((options?: ExecuteStreamOptions) => Middleware);
export declare const executeStream: ExecuteStreamMiddleware;
export declare const streamOnce: Middleware;
export declare class SimpleTools implements ToolRegistry {
    private tools;
    list(): Tool<unknown, unknown>[];
    get(name: string): Tool<unknown, unknown> | undefined;
    register(tool: Tool): void;
}
export interface CreateCtxOptions {
    model: LLM;
    input?: string;
    systemPrompt?: string;
    logLevel?: LogLevel;
    timestamps?: boolean;
    signal?: globalThis.AbortSignal;
    tools?: Tool[] | ToolRegistry;
    memory?: Memory;
    stream?: TokenStream;
    state?: Record<string, unknown>;
}
/**
 * Factory function to create a Ctx object with sensible defaults.
 * Reduces boilerplate by providing defaults for all optional fields.
 *
 * @example
 * ```ts
 * const ctx = createCtx({
 *   model: openAIAdapter({ model: 'gpt-5.4' }),
 *   input: 'Hello',
 *   systemPrompt: 'You are a helpful assistant',
 *   logLevel: 'debug'
 * });
 * ```
 */
export declare function createCtx(options: CreateCtxOptions): Ctx;
export type FlagMap = Record<string, string | boolean>;
export declare function parseFlags(argv?: string[]): FlagMap;
export declare function configFromFlagsAndEnv(envVars: string[], flags?: FlagMap, env?: typeof process.env): Record<string, string | undefined>;
export declare function firstConfigValue(names: string[], flags?: FlagMap, env?: typeof process.env): string | undefined;
export {};