import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { ToolHistoryReader } from "@mono-agent/agent-harness";
import type { ToolPolicyInput } from "@mono-agent/agent-harness";
import * as z from "zod/v4";
import type { RuntimeOptionsExtension } from "./runtime-option-extensions.js";
export declare const SESSION_HISTORY_MCP_SERVER_NAME = "mono-agent-session-history";
export declare const SESSION_HISTORY_TOOL_NAME = "SessionHistory";
declare const SESSION_HISTORY_INPUT_SCHEMA: z.ZodObject<{
    action: z.ZodOptional<z.ZodEnum<{
        search: "search";
        get: "get";
    }>>;
    query: z.ZodOptional<z.ZodString>;
    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
    states: z.ZodOptional<z.ZodArray<z.ZodEnum<{
        cancelled: "cancelled";
        timeout: "timeout";
        signal: "signal";
        error: "error";
        success: "success";
        rejected: "rejected";
        interrupted: "interrupted";
        exit_nonzero: "exit_nonzero";
    }>>>;
    runIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
    fromMs: z.ZodOptional<z.ZodNumber>;
    toMs: z.ZodOptional<z.ZodNumber>;
    includeIsolated: z.ZodOptional<z.ZodBoolean>;
    limit: z.ZodOptional<z.ZodNumber>;
    recordId: z.ZodOptional<z.ZodString>;
    toolCallId: z.ZodOptional<z.ZodString>;
    chunkBytes: z.ZodOptional<z.ZodNumber>;
    cursor: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
type SessionHistoryInput = z.infer<typeof SESSION_HISTORY_INPUT_SCHEMA>;
type SessionHistoryToolPolicy = Pick<ToolPolicyInput, "allowedTools" | "disallowedTools">;
export interface SessionHistoryBinding {
    readonly reader: ToolHistoryReader;
    readonly conversationId: string;
    readonly logicalConversationId: string;
    readonly runId: string;
}
export interface SessionHistoryRuntimeExtensionOptions {
    readonly historyRoot: string;
    readonly rollover?: "none" | "daily";
    readonly onUnavailable?: (error: unknown) => void;
}
/** Resolve canonical, legacy, MCP-prefixed, and server-wildcard policy spellings. */
export declare function isSessionHistoryToolAllowed(policy: SessionHistoryToolPolicy | undefined): boolean;
export declare function createSessionHistoryServer(binding: SessionHistoryBinding): McpServer;
export declare function createSessionHistoryRuntimeExtension(options: SessionHistoryRuntimeExtensionOptions): RuntimeOptionsExtension;
/** @internal Exported for focused authorization and cursor tests. */
export declare function handleSessionHistoryRequest(binding: SessionHistoryBinding, input: SessionHistoryInput): {
    content: {
        type: "text";
        text: string;
    }[];
    structuredContent: {
        action: "search" | "get";
        error: {
            code: string;
            message: string;
        };
        untrusted: true;
        notice: string;
    };
    isError: boolean;
} | {
    content: {
        readonly type: "text";
        readonly text: string;
    }[];
    structuredContent: {
        action: "get";
        tombstone: {
            readonly recordId: string;
            readonly reason: string;
            readonly removedAtMs: number;
        };
        untrusted: true;
        notice: string;
    };
} | {
    content: {
        readonly type: "text";
        readonly text: string;
    }[];
    structuredContent: {
        action: "get";
        record: {
            nextCursor?: string;
            truncated: boolean;
            originalBytes: number;
            retainedBytes: number;
            recovered: boolean;
            isolated: boolean;
            artifactReferences: readonly import("@mono-agent/agent-harness").ToolHistoryArtifactReference[];
            chunk: unknown;
            chunkOffset: number;
            detailCode?: string;
            failureKind?: string;
            state?: import("@mono-agent/runtime-adapter").RuntimeToolLifecycleTerminalState;
            recordId: string;
            runId: string;
            toolCallId: string;
            toolName: string;
            phase: "result" | "invocation";
            sequence: number;
        };
        untrusted: true;
        notice: string;
    };
} | {
    content: {
        readonly type: "text";
        readonly text: string;
    }[];
    structuredContent: {
        untrusted: true;
        notice: string;
        nextCursor?: string;
        action: "search";
        items: {
            isolated: boolean;
            recovered: boolean;
            preview: unknown;
            truncated: boolean;
            artifactReferences: readonly import("@mono-agent/agent-harness").ToolHistoryArtifactReference[];
            untrusted: true;
            endedAtMs?: number;
            startedAtMs: number;
            state?: import("@mono-agent/runtime-adapter").RuntimeToolLifecycleTerminalState;
            endSequence?: number;
            runId: string;
            toolCallId: string;
            toolName: string;
            startSequence: number;
            resultRecordId?: string;
            recordId: string;
        }[];
        count: number;
        hasMore: boolean;
    };
};
export {};
//# sourceMappingURL=session-history.d.ts.map