import type { AssistantMessage, Message, TextContent, ThinkingContent, Tool, ToolCall } from "@earendil-works/pi-ai";
export declare const SESSION_PROTOCOL_VERSION: 13;
export declare const SESSION_PROTOCOL_MAX_EXEC_CAPTURE_BYTES: number;
export declare const SESSION_PROTOCOL_MAX_EXEC_STDIN_BYTES: number;
export declare const SESSION_PROTOCOL_MAX_CLIENT_TOOL_PRESENTATION_BYTES: number;
export declare const SESSION_PROTOCOL_MAX_CLIENT_TOOL_PRESENTATION_LABEL_BYTES: number;
export declare const SESSION_PROTOCOL_MAX_CLIENT_TOOL_PRESENTATION_SUBJECT_BYTES: number;
export declare const SESSION_PROTOCOL_MAX_CLIENT_TOOL_PRESENTATION_DETAILS = 1024;
export declare const SESSION_PROTOCOL_MAX_CLIENT_TOOL_PRESENTATION_DETAIL_BYTES: number;
export declare const SESSION_PROTOCOL_MAX_CLIENT_TOOL_PRESENTATION_METADATA = 1024;
export declare const SESSION_PROTOCOL_MAX_CLIENT_TOOL_PRESENTATION_METADATA_VALUE_BYTES: number;
export declare const SESSION_PROTOCOL_MAX_ATTRIBUTE_VALUE_CHARS = 1024;
export declare const SESSION_PROTOCOL_MAX_SUBAGENT_ACTIVITIES = 64;
export declare const SESSION_PROTOCOL_MAX_SUBAGENT_SHORT_TEXT_BYTES = 512;
export declare const SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_SUBJECT_BYTES: number;
export declare const SESSION_PROTOCOL_MAX_SUBAGENT_ASSISTANT_TEXT_BYTES: number;
export declare const SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_DETAILS_BYTES: number;
export declare const SESSION_PROTOCOL_MAX_SUBAGENT_TOOL_METADATA_BYTES: number;
export declare const SESSION_PROTOCOL_MAX_SUBAGENT_NOTICE_CONTENT_BYTES: number;
export declare const SESSION_PROTOCOL_METHODS: readonly ["initialize", "session.create", "session.list", "session.observe", "session.unobserve", "session.record", "session.submit", "session.queue", "session.steer", "session.cancelPendingMessages", "session.retry", "session.exec", "session.cancelExec", "session.sample", "session.interrupt", "session.snapshot", "session.startGoal", "session.resumeGoal", "session.clearGoal", "session.setReasoning", "session.setPersona", "session.resolvePrompt", "session.autocompletePaths", "session.reload", "session.compact", "session.rewind", "session.interruptSubagent", "session.ephemeral.create", "session.ephemeral.submit", "session.ephemeral.close", "session.clientTool.ack", "session.clientTool.result"];
export type SessionProtocolMethod = (typeof SESSION_PROTOCOL_METHODS)[number];
export declare const SESSION_PROTOCOL_ERROR_CODES: {
    readonly parseError: "parse_error";
    readonly invalidRequest: "invalid_request";
    readonly methodNotFound: "method_not_found";
    readonly invalidParams: "invalid_params";
    readonly notFound: "not_found";
    readonly busy: "busy";
    readonly cancelled: "cancelled";
    readonly internalError: "internal_error";
};
export type SessionProtocolErrorCode = (typeof SESSION_PROTOCOL_ERROR_CODES)[keyof typeof SESSION_PROTOCOL_ERROR_CODES];
export type SessionProtocolRequestId = string;
export type SessionProtocolClientToolDefinition = {
    name: string;
    description: string;
    parameters: unknown;
    executionTimeoutMs?: number;
};
export type SessionProtocolInitializeParams = {
    client: {
        name: string;
        version: string;
        tools?: SessionProtocolClientToolDefinition[];
    };
};
export type SessionProtocolLocalExecutionEnvironmentInput = {
    kind: "local";
    cwd: string;
    env?: Record<string, string>;
};
export type SessionProtocolCloudflareSandboxExecutionEnvironmentInput = {
    kind: "cloudflare-sandbox";
    bridgeId: string;
    sandboxId: string;
    cwd: string;
};
export type SessionProtocolFlySpriteExecutionEnvironmentInput = {
    kind: "fly-sprite";
    apiId: string;
    spriteName: string;
    cwd: string;
};
export type SessionProtocolExecutionEnvironmentInput = SessionProtocolLocalExecutionEnvironmentInput | SessionProtocolCloudflareSandboxExecutionEnvironmentInput | SessionProtocolFlySpriteExecutionEnvironmentInput;
export type SessionProtocolCreateParams = {
    executionEnvironment: SessionProtocolExecutionEnvironmentInput;
    attributes: Record<string, string>;
    personaId?: string;
    reasoning?: SessionProtocolReasoningEffort;
};
export type SessionProtocolListParams = Record<string, never>;
export type SessionProtocolSessionIdParams = {
    sessionId: string;
};
export type SessionProtocolUnobserveParams = SessionProtocolSessionIdParams;
export type SessionProtocolUserMessageParams = {
    sessionId: string;
    text: string;
    historyEntryId?: string;
};
export type SessionProtocolSubmitParams = SessionProtocolUserMessageParams;
export type SessionProtocolQueueParams = SessionProtocolUserMessageParams;
export type SessionProtocolSteerParams = SessionProtocolSessionIdParams & {
    text: string;
};
export type SessionProtocolCancelPendingMessagesParams = SessionProtocolSessionIdParams;
export type SessionProtocolRecordParams = SessionProtocolSessionIdParams & {
    text: string;
    historyEntryId?: string;
};
export type SessionProtocolRetryParams = SessionProtocolSessionIdParams;
export type SessionProtocolStartGoalParams = SessionProtocolSessionIdParams & {
    objective: string;
};
export type SessionProtocolResumeGoalParams = SessionProtocolSessionIdParams;
export type SessionProtocolClearGoalParams = SessionProtocolSessionIdParams;
export type SessionProtocolExecParams = SessionProtocolSessionIdParams & {
    execId: string;
    command: string;
    args?: string[];
    env?: Record<string, string>;
    stdinBase64?: string;
    cwd?: string;
    timeoutMs?: number;
    maxCaptureBytes?: number;
};
export type SessionProtocolCancelExecParams = SessionProtocolSessionIdParams & {
    execId: string;
};
export type SessionProtocolSampleContext = {
    systemPrompt: string;
    messages: Message[];
    tools?: Tool[];
};
export type SessionProtocolSampleOptions = {
    reasoning?: SessionProtocolReasoningEffort;
    maxTokens?: number;
};
export type SessionProtocolSampleParams = SessionProtocolSessionIdParams & {
    context: SessionProtocolSampleContext;
    options: SessionProtocolSampleOptions;
};
export type SessionProtocolSetReasoningParams = SessionProtocolSessionIdParams & {
    reasoning: SessionProtocolReasoningEffort;
};
export type SessionProtocolSetPersonaParams = SessionProtocolSessionIdParams & {
    personaId: string;
};
export type SessionProtocolSettingsUpdateResult = {
    revision: number;
    settings: SessionProtocolSettingsSnapshot;
};
export type SessionProtocolResolvePromptParams = SessionProtocolSessionIdParams & {
    promptId: string;
};
export type SessionProtocolAutocompletePathsParams = SessionProtocolSessionIdParams & {
    query: string;
    limit: number;
};
export type SessionProtocolReloadParams = SessionProtocolSessionIdParams;
export type SessionProtocolCompactParams = SessionProtocolSessionIdParams & {
    mode: "summary-only" | "summary-and-last";
    guidance?: string;
};
export type SessionProtocolRewindParams = SessionProtocolSessionIdParams & {
    historyEntryId: string;
};
export type SessionProtocolInterruptSubagentParams = SessionProtocolSessionIdParams & {
    subagentId: string;
};
export type SessionProtocolEphemeralAgentTool = "bash" | "write" | "edit" | "view_image" | "web";
export type SessionProtocolEphemeralCreateParams = SessionProtocolSessionIdParams & {
    instructions: string;
    tools: SessionProtocolEphemeralAgentTool[];
    reasoning?: SessionProtocolReasoningEffort;
};
export type SessionProtocolEphemeralSubmitParams = SessionProtocolSessionIdParams & {
    contextId: string;
    threadId: string;
    forkFromThreadId?: string;
    message: string;
    reasoning?: SessionProtocolReasoningEffort;
};
export type SessionProtocolEphemeralCloseParams = SessionProtocolSessionIdParams & {
    contextId: string;
};
export type SessionProtocolClientToolPresentation = {
    subject?: string;
    subjectWrap?: "word" | "character";
    details?: Array<{
        text: string;
        tone?: "added" | "removed";
        wrap?: "word" | "character";
    }>;
    metadata?: string[];
};
export type SessionProtocolClientToolAckParams = SessionProtocolSessionIdParams & {
    callId: string;
    presentation?: SessionProtocolClientToolPresentation;
};
export type SessionProtocolClientToolResultParams = SessionProtocolSessionIdParams & {
    callId: string;
} & ({
    ok: true;
    content: string;
    presentation?: SessionProtocolClientToolPresentation;
} | {
    ok: false;
    error: string;
    presentation?: SessionProtocolClientToolPresentation;
});
export type SessionProtocolParamsByMethod = {
    initialize: SessionProtocolInitializeParams;
    "session.create": SessionProtocolCreateParams;
    "session.list": SessionProtocolListParams;
    "session.observe": SessionProtocolSessionIdParams;
    "session.unobserve": SessionProtocolUnobserveParams;
    "session.record": SessionProtocolRecordParams;
    "session.submit": SessionProtocolSubmitParams;
    "session.queue": SessionProtocolQueueParams;
    "session.steer": SessionProtocolSteerParams;
    "session.cancelPendingMessages": SessionProtocolCancelPendingMessagesParams;
    "session.retry": SessionProtocolRetryParams;
    "session.exec": SessionProtocolExecParams;
    "session.cancelExec": SessionProtocolCancelExecParams;
    "session.sample": SessionProtocolSampleParams;
    "session.interrupt": SessionProtocolSessionIdParams;
    "session.snapshot": SessionProtocolSessionIdParams;
    "session.startGoal": SessionProtocolStartGoalParams;
    "session.resumeGoal": SessionProtocolResumeGoalParams;
    "session.clearGoal": SessionProtocolClearGoalParams;
    "session.setReasoning": SessionProtocolSetReasoningParams;
    "session.setPersona": SessionProtocolSetPersonaParams;
    "session.resolvePrompt": SessionProtocolResolvePromptParams;
    "session.autocompletePaths": SessionProtocolAutocompletePathsParams;
    "session.reload": SessionProtocolReloadParams;
    "session.compact": SessionProtocolCompactParams;
    "session.rewind": SessionProtocolRewindParams;
    "session.interruptSubagent": SessionProtocolInterruptSubagentParams;
    "session.ephemeral.create": SessionProtocolEphemeralCreateParams;
    "session.ephemeral.submit": SessionProtocolEphemeralSubmitParams;
    "session.ephemeral.close": SessionProtocolEphemeralCloseParams;
    "session.clientTool.ack": SessionProtocolClientToolAckParams;
    "session.clientTool.result": SessionProtocolClientToolResultParams;
};
export type SessionProtocolInitializeResult = {
    protocolVersion: typeof SESSION_PROTOCOL_VERSION;
    methods: SessionProtocolMethod[];
    alreadyInitialized: boolean;
};
export type SessionProtocolTurnOutcome = {
    status: "completed";
    stopReason: "stop" | "length" | "toolUse";
} | {
    status: "failed";
    stopReason: "error";
    errorMessage?: string;
} | {
    status: "aborted";
    stopReason: "aborted";
} | {
    status: "blocked";
    reason: "auto-compaction-failed";
    message: string;
};
export type SessionProtocolTurnRecord = {
    userHistoryEntryId: string;
    state: "running";
} | {
    userHistoryEntryId: string;
    state: "settled";
    outcome: SessionProtocolTurnOutcome;
};
export type SessionProtocolTurnResult = {
    turn: SessionProtocolTurnOutcome;
};
export type SessionProtocolUserMessageTurnResult = SessionProtocolTurnResult & {
    userHistoryEntryId: string;
};
export type SessionProtocolSubmitResult = SessionProtocolUserMessageTurnResult;
export type SessionProtocolQueueResult = SessionProtocolUserMessageTurnResult;
export type SessionProtocolSteerResult = SessionProtocolUserMessageTurnResult;
export type SessionProtocolPendingUserMessage = {
    id: string;
    mode: "queue" | "steer";
    text: string;
};
export type SessionProtocolPendingUserMessagesState = {
    revision: number;
    messages: SessionProtocolPendingUserMessage[];
};
export type SessionProtocolSubagentActivity = {
    type: "assistant";
    text: string;
} | {
    type: "tool";
    toolName: string;
    outcome: "succeeded" | "failed" | "blocked" | "cancelled";
    presentation: {
        action: string;
        operation?: string;
        subject: string;
        subjectWrap: "word" | "character";
        details: Array<{
            text: string;
            tone?: "added" | "removed";
            wrap: "word" | "character";
        }>;
        metadata: string[];
    };
} | {
    type: "notice";
    severity: "info" | "warn" | "error";
    title: string;
    content?: string[];
};
export type SessionProtocolSubagentActivitiesAgentState = {
    runRevision: number;
    activities: SessionProtocolSubagentActivity[];
};
export type SessionProtocolSubagentActivitiesState = {
    revision: number;
    agents: Record<string, SessionProtocolSubagentActivitiesAgentState>;
};
export type SessionProtocolSubagentActivitiesChange = {
    type: "agent.set";
    agentId: string;
    state: SessionProtocolSubagentActivitiesAgentState;
} | {
    type: "agent.remove";
    agentId: string;
};
export type SessionProtocolCreateResult = {
    sessionId: string;
};
export type SessionProtocolStartGoalResult = SessionProtocolSubmitResult;
export type SessionProtocolResumeGoalResult = SessionProtocolTurnResult;
export type SessionProtocolClearGoalResult = SessionProtocolSnapshot;
export type SessionProtocolObserveResult = {
    snapshot: SessionProtocolSnapshot;
    pendingUserMessages: SessionProtocolPendingUserMessagesState;
    subagentActivities: SessionProtocolSubagentActivitiesState;
};
export type SessionProtocolCancelPendingMessagesResult = {
    cancelled: SessionProtocolPendingUserMessage[];
};
export type SessionProtocolRecordResult = {
    snapshot: SessionProtocolSnapshot;
    userHistoryEntryId: string;
};
export type SessionProtocolRetryResult = SessionProtocolTurnResult;
export type SessionProtocolExecResult = {
    output: string;
    stdout: string;
    stderr: string;
    exitCode: number | null;
    truncated: boolean;
    timedOut: boolean;
    aborted: boolean;
    closeSignal: string | null;
};
export type SessionProtocolCancelExecResult = {
    cancelled: boolean;
};
export type SessionProtocolSampleResult = {
    message: AssistantMessage;
};
export type SessionProtocolSessionLifecycle = "idle" | "running";
export type SessionProtocolSessionSummary = {
    sessionId: string;
    lifecycle: SessionProtocolSessionLifecycle;
};
export type SessionProtocolListResult = {
    sessions: SessionProtocolSessionSummary[];
};
export type SessionProtocolSystemMessage = {
    role: "system";
    content: string;
    timestamp: number;
};
export type SessionProtocolDraftAssistantMessage = {
    role: "assistant";
    content: (TextContent | ThinkingContent | ToolCall)[];
    timestamp: number;
};
export type SessionProtocolMessagePayload = SessionProtocolSystemMessage | Message | SessionProtocolDraftAssistantMessage;
export type SessionProtocolMessageState = "draft" | "committed" | "interrupted" | "discarded";
export type SessionProtocolMessage = {
    id: string;
    state: SessionProtocolMessageState;
    modelVisible: boolean;
    message: SessionProtocolMessagePayload;
};
export type SessionProtocolSubject = {
    type: "session";
} | {
    type: "message";
    id: string;
} | {
    type: "tool";
    id: string;
} | {
    type: "agent";
    id: string;
} | {
    type: "operation";
    id: string;
};
export type SessionProtocolTimelineNotice = {
    kind: string;
    version: number;
    severity: "info" | "warn" | "error";
    subject: SessionProtocolSubject;
    presentation: {
        title: string;
        content?: string[];
    };
    data: Record<string, unknown>;
};
export declare function projectSessionProtocolNoticePresentation(title: string, content?: readonly string[]): SessionProtocolTimelineNotice["presentation"];
export declare function projectSessionProtocolSubagentActivity(activity: SessionProtocolSubagentActivity): SessionProtocolSubagentActivity;
export type SessionProtocolTimelineItem = {
    type: "message";
    id: string;
    sequence: number;
    createdAt: number;
    messageId: string;
} | {
    type: "tool";
    id: string;
    sequence: number;
    createdAt: number;
    toolId: string;
} | {
    type: "notice";
    id: string;
    sequence: number;
    createdAt: number;
    notice: SessionProtocolTimelineNotice;
} | {
    type: "operation";
    id: string;
    sequence: number;
    createdAt: number;
    operationId: string;
};
export type SessionProtocolTimeline = {
    epoch: number;
    sequence: number;
    items: SessionProtocolTimelineItem[];
};
type SessionProtocolOperationBase = {
    id: string;
    kind: "auto-compaction" | "manual-compaction" | "reload" | "rewind";
    startedAt: number;
};
export type SessionProtocolOperation = SessionProtocolOperationBase & ({
    status: "running";
} | {
    status: "succeeded";
    finishedAt: number;
} | {
    status: "failed";
    finishedAt: number;
    error: string;
} | {
    status: "skipped";
    finishedAt: number;
    reason: "no-eligible-history";
} | {
    status: "cancelled";
    finishedAt: number;
    reason: "interrupted" | "session-recovered";
});
export type SessionProtocolPromptCompositionSnapshot = {
    environmentTag: string;
    subagentPrompts: Record<string, string>;
};
export type SessionProtocolReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
export type SessionProtocolThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
export type SessionProtocolServiceTier = "priority" | "flex";
export type SessionProtocolModelSnapshot = {
    id: string;
    name: string;
    api: string;
    provider: string;
    baseUrl: string;
    reasoning: boolean;
    thinkingLevelMap?: Partial<Record<SessionProtocolThinkingLevel, string | null>>;
    input: ("text" | "image")[];
    cost: {
        input: number;
        output: number;
        cacheRead: number;
        cacheWrite: number;
        tiers?: Array<{
            inputTokensAbove: number;
            input: number;
            output: number;
            cacheRead: number;
            cacheWrite: number;
        }>;
    };
    contextWindow: number;
    maxTokens: number;
    compat?: unknown;
};
export type SessionProtocolPersonaSettingsSnapshot = {
    reasoning?: SessionProtocolReasoningEffort;
    interleavedThinking?: boolean;
    serviceTier?: SessionProtocolServiceTier;
};
export type SessionProtocolSubagentSnapshot = {
    description?: string;
    tools?: string[];
    launchModels?: string[];
};
export type SessionProtocolPersonaSnapshot = {
    id: string;
    label: string;
    description?: string;
    allowedReasoningLevels?: SessionProtocolReasoningEffort[];
    subagents?: Record<string, SessionProtocolSubagentSnapshot>;
    tools?: string[];
    skills: string[] | "*";
    source: "builtin" | "user" | "project";
};
export type SessionProtocolBootstrapSnapshot = {
    model: SessionProtocolModelSnapshot;
    prompt: SessionProtocolPromptCompositionSnapshot;
};
export type SessionProtocolPromptTemplateSnapshot = {
    id: string;
    label?: string;
    description?: string;
};
export type SessionProtocolSkillSnapshot = {
    name: string;
    description: string;
    path: string;
};
export type SessionProtocolContentCatalogSnapshot = {
    personas: SessionProtocolPersonaSnapshot[];
    prompts: SessionProtocolPromptTemplateSnapshot[];
    skills: SessionProtocolSkillSnapshot[];
};
export type SessionProtocolSettingsSnapshot = {
    personaId: string;
    reasoning?: SessionProtocolReasoningEffort;
    serviceTier?: SessionProtocolServiceTier;
};
export type SessionProtocolLocalExecutionEnvironmentSnapshot = {
    kind: "local";
    cwd: string;
    home: string;
    env?: Record<string, string>;
};
export type SessionProtocolCloudflareSandboxExecutionEnvironmentSnapshot = {
    kind: "cloudflare-sandbox";
    bridgeId: string;
    sandboxId: string;
    cwd: string;
    home: string;
};
export type SessionProtocolFlySpriteExecutionEnvironmentSnapshot = {
    kind: "fly-sprite";
    apiId: string;
    spriteName: string;
    cwd: string;
    home: string;
};
export type SessionProtocolExecutionEnvironmentSnapshot = SessionProtocolLocalExecutionEnvironmentSnapshot | SessionProtocolCloudflareSandboxExecutionEnvironmentSnapshot | SessionProtocolFlySpriteExecutionEnvironmentSnapshot;
export type SessionProtocolAgentStateSnapshot = {
    revision: number;
    modelContextKey: string;
    usageCheckpoint?: {
        historyEntryId: string;
        modelContextKey: string;
        tokens: number;
    };
};
export type SessionProtocolGoal = {
    objective: string;
    status: "active" | "blocked";
};
export type SessionProtocolSnapshot = {
    sessionId: string;
    attributes: Record<string, string>;
    createdAt: number;
    revision: number;
    agentState: SessionProtocolAgentStateSnapshot;
    lifecycle: SessionProtocolSessionLifecycle;
    goal: SessionProtocolGoal | null;
    costTotal: number;
    settings: SessionProtocolSettingsSnapshot;
    bootstrap: SessionProtocolBootstrapSnapshot;
    catalog: SessionProtocolContentCatalogSnapshot;
    executionEnvironment: SessionProtocolExecutionEnvironmentSnapshot;
    messages: SessionProtocolMessage[];
    turns: Record<string, SessionProtocolTurnRecord>;
    timeline: SessionProtocolTimeline;
    tools: Record<string, SessionProtocolToolRun>;
    operations: Record<string, SessionProtocolOperation>;
    agents: Record<string, SessionProtocolAgentRun>;
    facets: Record<string, SessionProtocolFacet>;
};
type SessionProtocolToolRunBase = {
    id: string;
    toolCallId: string;
    toolName: string;
    facetIds: string[];
};
type SessionProtocolToolPosition = {
    messageId: string;
    contentIndex: number;
};
export type SessionProtocolToolRun = (SessionProtocolToolRunBase & {
    status: "streaming";
    origin: SessionProtocolToolPosition;
}) | (SessionProtocolToolRunBase & {
    status: "queued" | "running" | "succeeded" | "failed" | "blocked" | "cancelled";
    call: SessionProtocolToolPosition;
    startedAt?: number;
    finishedAt?: number;
    resultMessageId?: string;
    summary?: string;
    error?: string;
});
export type SessionProtocolAgentRunFailure = {
    kind: "interrupted";
    message: string;
} | {
    kind: "auto-compaction-failed" | "model-subturn-limit" | "runtime-error";
    message: string;
} | {
    kind: "provider-error";
    message: string;
    stopReason: string;
};
type SessionProtocolAgentFailedRunFailure = Exclude<SessionProtocolAgentRunFailure, {
    kind: "interrupted";
}>;
type SessionProtocolAgentInterruptedRunFailure = Extract<SessionProtocolAgentRunFailure, {
    kind: "interrupted";
}>;
type SessionProtocolAgentRunStateBase = {
    revision: number;
    startedAt: number;
    interruptRequested: boolean;
};
export type SessionProtocolAgentRunState = (SessionProtocolAgentRunStateBase & {
    status: "running";
}) | (SessionProtocolAgentRunStateBase & {
    status: "succeeded";
    finishedAt: number;
    response: string;
}) | (SessionProtocolAgentRunStateBase & {
    status: "failed";
    finishedAt: number;
    failure: SessionProtocolAgentFailedRunFailure;
}) | (SessionProtocolAgentRunStateBase & {
    status: "interrupted";
    finishedAt: number;
    failure: SessionProtocolAgentInterruptedRunFailure;
});
export type SessionProtocolAgentRun = {
    id: string;
    name: string;
    title: string;
    availability: "running" | "idle";
    model: {
        provider: string;
        id: string;
        reasoning: SessionProtocolReasoningEffort;
    };
    workingDirectory: string;
    createdAt: number;
    run: SessionProtocolAgentRunState;
    costTotal: number;
    usage: {
        input: number;
        output: number;
        cacheRead: number;
        cacheWrite: number;
        contextWindowUsageTokens: number;
        contextWindow: number;
    };
};
export type SessionProtocolFacetSubject = SessionProtocolSubject;
export type SessionProtocolFacet = {
    id: string;
    subject: SessionProtocolFacetSubject;
    kind: string;
    version: number;
    data: Record<string, unknown>;
};
export type SessionProtocolInterruptResult = {
    interrupted: boolean;
    isTurnRunning: boolean;
};
export type SessionProtocolCompactResult = {
    snapshot: SessionProtocolSnapshot;
    compactionMessage: string;
    includedLastAssistant: boolean;
};
export type SessionProtocolRewindResult = {
    snapshot: SessionProtocolSnapshot;
    historyEntryId: string;
    text: string;
    removedEntryIds: string[];
};
export type SessionProtocolReloadResult = {
    snapshot: SessionProtocolSnapshot;
    warnings: string[];
    counts: {
        personas: number;
        prompts: number;
        skills: number;
    };
};
export type SessionProtocolResolvePromptResult = {
    promptId: string;
    text: string;
};
export type SessionProtocolAutocompletePathsResult = {
    paths: string[];
};
export type SessionProtocolUnobserveResult = {
    unobserved: true;
};
export type SessionProtocolInterruptSubagentResult = {
    found: boolean;
};
export type SessionProtocolEphemeralCreateResult = {
    contextId: string;
};
export type SessionProtocolEphemeralSubmitResult = {
    threadId: string;
    response: string;
};
export type SessionProtocolEphemeralCloseResult = {
    closed: boolean;
};
export type SessionProtocolClientToolAckResult = {
    accepted: boolean;
};
export type SessionProtocolClientToolResultResult = {
    accepted: boolean;
};
export type SessionProtocolResultByMethod = {
    initialize: SessionProtocolInitializeResult;
    "session.create": SessionProtocolCreateResult;
    "session.list": SessionProtocolListResult;
    "session.observe": SessionProtocolObserveResult;
    "session.unobserve": SessionProtocolUnobserveResult;
    "session.record": SessionProtocolRecordResult;
    "session.submit": SessionProtocolSubmitResult;
    "session.queue": SessionProtocolQueueResult;
    "session.steer": SessionProtocolSteerResult;
    "session.cancelPendingMessages": SessionProtocolCancelPendingMessagesResult;
    "session.retry": SessionProtocolRetryResult;
    "session.exec": SessionProtocolExecResult;
    "session.cancelExec": SessionProtocolCancelExecResult;
    "session.sample": SessionProtocolSampleResult;
    "session.interrupt": SessionProtocolInterruptResult;
    "session.snapshot": SessionProtocolSnapshot;
    "session.startGoal": SessionProtocolStartGoalResult;
    "session.resumeGoal": SessionProtocolResumeGoalResult;
    "session.clearGoal": SessionProtocolClearGoalResult;
    "session.setReasoning": SessionProtocolSettingsUpdateResult;
    "session.setPersona": SessionProtocolSnapshot;
    "session.resolvePrompt": SessionProtocolResolvePromptResult;
    "session.autocompletePaths": SessionProtocolAutocompletePathsResult;
    "session.reload": SessionProtocolReloadResult;
    "session.compact": SessionProtocolCompactResult;
    "session.rewind": SessionProtocolRewindResult;
    "session.interruptSubagent": SessionProtocolInterruptSubagentResult;
    "session.ephemeral.create": SessionProtocolEphemeralCreateResult;
    "session.ephemeral.submit": SessionProtocolEphemeralSubmitResult;
    "session.ephemeral.close": SessionProtocolEphemeralCloseResult;
    "session.clientTool.ack": SessionProtocolClientToolAckResult;
    "session.clientTool.result": SessionProtocolClientToolResultResult;
};
export type SessionProtocolRequestMessage = {
    [M in SessionProtocolMethod]: {
        version: typeof SESSION_PROTOCOL_VERSION;
        type: "request";
        id: SessionProtocolRequestId;
        method: M;
        params: SessionProtocolParamsByMethod[M];
    };
}[SessionProtocolMethod];
export type SessionProtocolSuccessResponseMessage = {
    version: typeof SESSION_PROTOCOL_VERSION;
    type: "response";
    id: SessionProtocolRequestId;
    ok: true;
    result: SessionProtocolResultByMethod[SessionProtocolMethod];
};
export type SessionProtocolError = {
    code: SessionProtocolErrorCode;
    message: string;
    data?: unknown;
};
export type SessionProtocolErrorResponseMessage = {
    version: typeof SESSION_PROTOCOL_VERSION;
    type: "response";
    id: SessionProtocolRequestId | null;
    ok: false;
    error: SessionProtocolError;
};
export type SessionProtocolResponseMessage = SessionProtocolSuccessResponseMessage | SessionProtocolErrorResponseMessage;
export type SessionProtocolParsedSuccessResponseMessage = Omit<SessionProtocolSuccessResponseMessage, "result"> & {
    result: unknown;
};
export type SessionProtocolParsedResponseMessage = SessionProtocolParsedSuccessResponseMessage | SessionProtocolErrorResponseMessage;
export type SessionProtocolDeltaCause = {
    type: "user-message" | "assistant-stream" | "assistant-message" | "tool-run" | "tool-result" | "notice" | "agent-run" | "maintenance" | "configuration" | "goal";
} | {
    type: "compaction";
    previousEpoch: number;
    epoch: number;
    kind: "auto" | "manual";
    cutType: "turn-boundary" | "split-turn";
    retainedMessageCount: number;
} | {
    type: "rewind";
    epoch: number;
    cutoffSequence: number;
} | {
    type: "resync";
};
export type SessionProtocolChange = {
    type: "agent-state.set";
    agentState: SessionProtocolAgentStateSnapshot;
} | {
    type: "lifecycle.set";
    lifecycle: SessionProtocolSessionLifecycle;
} | {
    type: "goal.set";
    goal: SessionProtocolGoal | null;
} | {
    type: "cost.set";
    costTotal: number;
} | {
    type: "settings.set";
    settings: SessionProtocolSettingsSnapshot;
} | {
    type: "turn.set";
    turn: SessionProtocolTurnRecord;
} | {
    type: "message.append";
    message: SessionProtocolMessage;
} | {
    type: "message.replace";
    message: SessionProtocolMessage;
} | {
    type: "message.content.append";
    messageId: string;
    text?: string;
    thinking?: string;
    timestamp: number;
} | {
    type: "timeline.append";
    item: SessionProtocolTimelineItem;
} | {
    type: "timeline.remove";
    id: string;
} | {
    type: "timeline.advance";
    epoch: number;
    sequence: number;
} | {
    type: "tool.set";
    tool: SessionProtocolToolRun;
} | {
    type: "tool.remove";
    id: string;
} | {
    type: "operation.set";
    operation: SessionProtocolOperation;
} | {
    type: "operation.remove";
    id: string;
} | {
    type: "agent.set";
    agent: SessionProtocolAgentRun;
} | {
    type: "agent.remove";
    id: string;
} | {
    type: "facet.set";
    facet: SessionProtocolFacet;
} | {
    type: "facet.remove";
    id: string;
};
export type SessionProtocolDelta = {
    type: "snapshot.patch";
    changes: SessionProtocolChange[];
} | {
    type: "snapshot.reset";
    snapshot: SessionProtocolSnapshot;
};
export type SessionProtocolDeltaMessage = {
    version: typeof SESSION_PROTOCOL_VERSION;
    type: "session.delta";
    sessionId: string;
    fromRevision: number | null;
    toRevision: number;
    cause: SessionProtocolDeltaCause;
    delta: SessionProtocolDelta;
};
export type SessionProtocolReadyMessage = {
    version: typeof SESSION_PROTOCOL_VERSION;
    type: "ready";
    methods: SessionProtocolMethod[];
};
export type SessionProtocolClientToolCallMessage = {
    version: typeof SESSION_PROTOCOL_VERSION;
    type: "session.clientTool.call";
    sessionId: string;
    agentId: string;
    callId: string;
    toolName: string;
    arguments: unknown;
    ackDeadlineMs: number;
    executionDeadlineMs: number;
};
export type SessionProtocolClientToolCancelMessage = {
    version: typeof SESSION_PROTOCOL_VERSION;
    type: "session.clientTool.cancel";
    sessionId: string;
    callId: string;
    reason: "aborted" | "timeout" | "client-detached" | "host-failed";
};
export type SessionProtocolClientToolMessage = SessionProtocolClientToolCallMessage | SessionProtocolClientToolCancelMessage;
export type SessionProtocolEphemeralAgentThreadUpdateEvent = {
    type: "ephemeral-agent.thread-update";
    contextId: string;
    threadId: string;
    update: {
        costTotal: number;
        usage: {
            input: number;
            output: number;
            cacheRead: number;
            cacheWrite: number;
            contextWindowUsageTokens: number;
            contextWindow: number;
        };
        lastActivityText?: string;
    };
};
export type SessionProtocolFeedbackTone = "default" | "error";
export type SessionProtocolFeedbackEvent = {
    type: "feedback.notice";
    title: string;
    tone: SessionProtocolFeedbackTone;
    presentation: "footer";
    durationMs: number;
};
export type SessionProtocolEphemeralTimelineEvent = {
    type: "timeline.item";
    epoch: number;
    item: Extract<SessionProtocolTimelineItem, {
        type: "notice";
    }>;
};
export type SessionProtocolEphemeralEvent = SessionProtocolEphemeralAgentThreadUpdateEvent | SessionProtocolFeedbackEvent | SessionProtocolEphemeralTimelineEvent;
export type SessionProtocolEphemeralMessage = {
    version: typeof SESSION_PROTOCOL_VERSION;
    type: "session.ephemeral";
    sessionId: string;
    event: SessionProtocolEphemeralEvent;
};
export type SessionProtocolPendingUserMessagesMessage = {
    version: typeof SESSION_PROTOCOL_VERSION;
    type: "session.pendingUserMessages";
    sessionId: string;
    state: SessionProtocolPendingUserMessagesState;
};
export type SessionProtocolSubagentActivitiesMessage = {
    version: typeof SESSION_PROTOCOL_VERSION;
    type: "session.subagentActivities";
    sessionId: string;
    revision: number;
    changes: SessionProtocolSubagentActivitiesChange[];
};
export type SessionProtocolOutgoingMessage = SessionProtocolResponseMessage | SessionProtocolDeltaMessage | SessionProtocolEphemeralMessage | SessionProtocolPendingUserMessagesMessage | SessionProtocolSubagentActivitiesMessage | SessionProtocolClientToolMessage | SessionProtocolReadyMessage;
export type SessionProtocolParsedOutgoingMessage = SessionProtocolParsedResponseMessage | SessionProtocolDeltaMessage | SessionProtocolEphemeralMessage | SessionProtocolPendingUserMessagesMessage | SessionProtocolSubagentActivitiesMessage | SessionProtocolClientToolMessage | SessionProtocolReadyMessage;
export type SessionProtocolOutgoingParseFailureReason = "invalid_payload" | "empty_line" | "parse_error" | "unsupported_version" | "unsupported_message_type" | "response_invalid_id";
export type SessionProtocolOutgoingParseFailure = {
    ok: false;
    reason: SessionProtocolOutgoingParseFailureReason;
    messageType: SessionProtocolOutgoingMessage["type"] | null;
    id: SessionProtocolRequestId | null;
    error: SessionProtocolError;
};
export type SessionProtocolOutgoingParseSuccess = {
    ok: true;
    message: SessionProtocolParsedOutgoingMessage;
};
export type SessionProtocolOutgoingParseResult = SessionProtocolOutgoingParseFailure | SessionProtocolOutgoingParseSuccess;
export type SessionProtocolParseFailure = {
    ok: false;
    id: SessionProtocolRequestId | null;
    error: SessionProtocolError;
};
export type SessionProtocolParseSuccess = {
    ok: true;
    request: SessionProtocolRequestMessage;
};
export type SessionProtocolParseResult = SessionProtocolParseFailure | SessionProtocolParseSuccess;
export type SessionProtocolParamsValidationResult<T> = {
    ok: true;
    value: T;
} | {
    ok: false;
    error: SessionProtocolError;
};
export type SessionProtocolResultValidationResult<T> = {
    ok: true;
    value: T;
} | {
    ok: false;
    error: SessionProtocolError;
};
export declare function isSessionProtocolMethod(value: unknown): value is SessionProtocolMethod;
export declare function createSessionProtocolError(code: SessionProtocolErrorCode, message: string, data?: unknown): SessionProtocolError;
export declare function createSessionProtocolSuccessResponse<M extends SessionProtocolMethod>(id: SessionProtocolRequestId, method: M, result: SessionProtocolResultByMethod[M]): SessionProtocolSuccessResponseMessage;
export declare function createSessionProtocolErrorResponse(id: SessionProtocolRequestId | null, code: SessionProtocolErrorCode, message: string, data?: unknown): SessionProtocolErrorResponseMessage;
export declare function createSessionProtocolDeltaMessage(options: {
    sessionId: string;
    fromRevision: number | null;
    toRevision: number;
    cause: SessionProtocolDeltaCause;
    delta: SessionProtocolDelta;
}): SessionProtocolDeltaMessage;
export declare function createSessionProtocolEphemeralMessage(options: {
    sessionId: string;
    event: SessionProtocolEphemeralEvent;
}): SessionProtocolEphemeralMessage;
export declare function createSessionProtocolPendingUserMessagesMessage(options: {
    sessionId: string;
    state: SessionProtocolPendingUserMessagesState;
}): SessionProtocolPendingUserMessagesMessage;
export declare function applySessionProtocolSubagentActivitiesMessage(state: SessionProtocolSubagentActivitiesState, message: SessionProtocolSubagentActivitiesMessage): SessionProtocolSubagentActivitiesState;
export declare function createSessionProtocolSubagentActivitiesMessage(options: {
    sessionId: string;
    revision: number;
    changes: SessionProtocolSubagentActivitiesChange[];
}): SessionProtocolSubagentActivitiesMessage;
export declare function applySessionProtocolDelta(snapshot: SessionProtocolSnapshot, message: SessionProtocolDeltaMessage): SessionProtocolSnapshot;
export declare function createSessionProtocolReadyMessage(): SessionProtocolReadyMessage;
export declare function serializeSessionProtocolMessage(message: SessionProtocolOutgoingMessage): string;
export declare function parseSessionProtocolRequestLine(line: string): SessionProtocolParseResult;
export declare function createSessionProtocolRequest(id: SessionProtocolRequestId, method: SessionProtocolMethod, params: unknown): SessionProtocolParamsValidationResult<SessionProtocolRequestMessage>;
export declare function parseSessionProtocolOutgoingLine(line: string): SessionProtocolOutgoingParseResult;
export declare function validateSessionProtocolParams(method: "initialize", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolInitializeParams>;
export declare function validateSessionProtocolParams(method: "session.create", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolCreateParams>;
export declare function validateSessionProtocolParams(method: "session.list", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolListParams>;
export declare function validateSessionProtocolParams(method: "session.observe", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSessionIdParams>;
export declare function validateSessionProtocolParams(method: "session.unobserve", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolUnobserveParams>;
export declare function validateSessionProtocolParams(method: "session.record", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolRecordParams>;
export declare function validateSessionProtocolParams(method: "session.submit", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSubmitParams>;
export declare function validateSessionProtocolParams(method: "session.queue", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolQueueParams>;
export declare function validateSessionProtocolParams(method: "session.steer", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSteerParams>;
export declare function validateSessionProtocolParams(method: "session.cancelPendingMessages", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolCancelPendingMessagesParams>;
export declare function validateSessionProtocolParams(method: "session.retry", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolRetryParams>;
export declare function validateSessionProtocolParams(method: "session.exec", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolExecParams>;
export declare function validateSessionProtocolParams(method: "session.cancelExec", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolCancelExecParams>;
export declare function validateSessionProtocolParams(method: "session.sample", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSampleParams>;
export declare function validateSessionProtocolParams(method: "session.interrupt", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSessionIdParams>;
export declare function validateSessionProtocolParams(method: "session.snapshot", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSessionIdParams>;
export declare function validateSessionProtocolParams(method: "session.startGoal", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolStartGoalParams>;
export declare function validateSessionProtocolParams(method: "session.resumeGoal", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolResumeGoalParams>;
export declare function validateSessionProtocolParams(method: "session.clearGoal", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolClearGoalParams>;
export declare function validateSessionProtocolParams(method: "session.reload", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolReloadParams>;
export declare function validateSessionProtocolParams(method: "session.setReasoning", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSetReasoningParams>;
export declare function validateSessionProtocolParams(method: "session.setPersona", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolSetPersonaParams>;
export declare function validateSessionProtocolParams(method: "session.resolvePrompt", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolResolvePromptParams>;
export declare function validateSessionProtocolParams(method: "session.autocompletePaths", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolAutocompletePathsParams>;
export declare function validateSessionProtocolParams(method: "session.compact", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolCompactParams>;
export declare function validateSessionProtocolParams(method: "session.rewind", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolRewindParams>;
export declare function validateSessionProtocolParams(method: "session.interruptSubagent", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolInterruptSubagentParams>;
export declare function validateSessionProtocolParams(method: "session.ephemeral.create", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolEphemeralCreateParams>;
export declare function validateSessionProtocolParams(method: "session.ephemeral.submit", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolEphemeralSubmitParams>;
export declare function validateSessionProtocolParams(method: "session.ephemeral.close", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolEphemeralCloseParams>;
export declare function validateSessionProtocolParams(method: "session.clientTool.ack", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolClientToolAckParams>;
export declare function validateSessionProtocolParams(method: "session.clientTool.result", params: unknown): SessionProtocolParamsValidationResult<SessionProtocolClientToolResultParams>;
export declare function validateSessionProtocolParams(method: SessionProtocolMethod, params: unknown): SessionProtocolParamsValidationResult<SessionProtocolParamsByMethod[SessionProtocolMethod]>;
export declare function validateSessionProtocolResult<M extends SessionProtocolMethod>(method: M, result: unknown): SessionProtocolResultValidationResult<SessionProtocolResultByMethod[M]>;
export {};