/**
 * @license
 * Copyright 2025 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */
import { type Part, type PartListUnion, GenerateContentResponse, type FunctionDeclaration, FinishReason, GenerateContentResponseUsageMetadata } from '@google/genai';
import { type ToolCallConfirmationDetails, type ToolResult, type ToolResultDisplay } from '../tools/tools.js';
import { ToolErrorType } from '../tools/tool-error.js';
import { GeminiChat } from './geminiChat.js';
import { type ThoughtSummary } from '../utils/thoughtUtils.js';
export declare const DEFAULT_AGENT_ID = "primary";
export interface ServerTool {
    name: string;
    schema: FunctionDeclaration;
    execute(params: Record<string, unknown>, signal?: AbortSignal): Promise<ToolResult>;
    shouldConfirmExecute(params: Record<string, unknown>, abortSignal: AbortSignal): Promise<ToolCallConfirmationDetails | false>;
}
export declare enum GeminiEventType {
    Content = "content",
    ToolCallRequest = "tool_call_request",
    ToolCallResponse = "tool_call_response",
    ToolCallConfirmation = "tool_call_confirmation",
    UserCancelled = "user_cancelled",
    Error = "error",
    ChatCompressed = "chat_compressed",
    Thought = "thought",
    UsageMetadata = "usage_metadata",
    MaxSessionTurns = "max_session_turns",
    Finished = "finished",
    LoopDetected = "loop_detected",
    Citation = "citation",
    Retry = "retry",
    SystemNotice = "system_notice",
    InvalidStream = "invalid_stream",
    ContextWindowWillOverflow = "context_window_will_overflow",
    ModelInfo = "model_info"
}
export type ServerGeminiRetryEvent = {
    type: GeminiEventType.Retry;
};
export type ServerGeminiInvalidStreamEvent = {
    type: GeminiEventType.InvalidStream;
};
export type ServerGeminiContextWindowWillOverflowEvent = {
    type: GeminiEventType.ContextWindowWillOverflow;
    value: {
        estimatedRequestTokenCount: number;
        remainingTokenCount: number;
    };
};
export interface StructuredError {
    message: string;
    status?: number;
}
export interface GeminiErrorEventValue {
    error: StructuredError;
}
export interface ToolCallRequestInfo {
    callId: string;
    name: string;
    args: Record<string, unknown>;
    isClientInitiated: boolean;
    prompt_id: string;
    agentId?: string;
    checkpoint?: string;
}
export interface ToolCallResponseInfo {
    callId: string;
    responseParts: Part[];
    resultDisplay: ToolResultDisplay | undefined;
    error: Error | undefined;
    errorType: ToolErrorType | undefined;
    agentId?: string;
    /**
     * Optional flag to suppress display of this tool result
     * @requirement:HOOK-132 - AfterTool suppressOutput support
     */
    suppressDisplay?: boolean;
}
export interface ServerToolCallConfirmationDetails {
    request: ToolCallRequestInfo;
    details: ToolCallConfirmationDetails;
}
export type ServerGeminiContentEvent = {
    type: GeminiEventType.Content;
    value: string;
    traceId?: string;
};
export type ServerGeminiSystemNoticeEvent = {
    type: GeminiEventType.SystemNotice;
    value: string;
};
export type ServerGeminiThoughtEvent = {
    type: GeminiEventType.Thought;
    value: ThoughtSummary;
    traceId?: string;
};
export type ServerGeminiToolCallRequestEvent = {
    type: GeminiEventType.ToolCallRequest;
    value: ToolCallRequestInfo;
};
export type ServerGeminiToolCallResponseEvent = {
    type: GeminiEventType.ToolCallResponse;
    value: ToolCallResponseInfo;
};
export type ServerGeminiToolCallConfirmationEvent = {
    type: GeminiEventType.ToolCallConfirmation;
    value: ServerToolCallConfirmationDetails;
};
export type ServerGeminiUserCancelledEvent = {
    type: GeminiEventType.UserCancelled;
};
export type ServerGeminiErrorEvent = {
    type: GeminiEventType.Error;
    value: GeminiErrorEventValue;
};
export declare enum CompressionStatus {
    /** The compression was successful */
    COMPRESSED = 1,
    /** The compression failed due to the compression inflating the token count */
    COMPRESSION_FAILED_INFLATED_TOKEN_COUNT = 2,
    /** The compression failed due to an error counting tokens */
    COMPRESSION_FAILED_TOKEN_COUNT_ERROR = 3,
    /** The compression was not necessary and no action was taken */
    NOOP = 4
}
export interface ChatCompressionInfo {
    originalTokenCount: number;
    newTokenCount: number;
    compressionStatus: CompressionStatus;
}
export type ServerGeminiChatCompressedEvent = {
    type: GeminiEventType.ChatCompressed;
    value: ChatCompressionInfo | null;
};
export type ServerGeminiUsageMetadataEvent = {
    type: GeminiEventType.UsageMetadata;
    value: {
        promptTokenCount?: number;
        candidatesTokenCount?: number;
        totalTokenCount?: number;
        cachedContentTokenCount?: number;
    };
};
export type ServerGeminiMaxSessionTurnsEvent = {
    type: GeminiEventType.MaxSessionTurns;
};
export type ServerGeminiFinishedEvent = {
    type: GeminiEventType.Finished;
    value: {
        reason: FinishReason;
        usageMetadata?: GenerateContentResponseUsageMetadata;
    };
};
export type ServerGeminiLoopDetectedEvent = {
    type: GeminiEventType.LoopDetected;
};
export type ServerGeminiCitationEvent = {
    type: GeminiEventType.Citation;
    value: string;
};
export interface ModelInfo {
    model: string;
}
export type ServerGeminiModelInfoEvent = {
    type: GeminiEventType.ModelInfo;
    value: ModelInfo;
};
export type ServerGeminiStreamEvent = ServerGeminiContentEvent | ServerGeminiSystemNoticeEvent | ServerGeminiToolCallRequestEvent | ServerGeminiToolCallResponseEvent | ServerGeminiToolCallConfirmationEvent | ServerGeminiUserCancelledEvent | ServerGeminiErrorEvent | ServerGeminiChatCompressedEvent | ServerGeminiThoughtEvent | ServerGeminiUsageMetadataEvent | ServerGeminiMaxSessionTurnsEvent | ServerGeminiFinishedEvent | ServerGeminiLoopDetectedEvent | ServerGeminiCitationEvent | ServerGeminiRetryEvent | ServerGeminiInvalidStreamEvent | ServerGeminiContextWindowWillOverflowEvent | ServerGeminiModelInfoEvent;
export declare class Turn {
    private readonly chat;
    private readonly prompt_id;
    private readonly agentId;
    private readonly providerName;
    readonly pendingToolCalls: ToolCallRequestInfo[];
    private debugResponses;
    finishReason: FinishReason | undefined;
    private logger;
    constructor(chat: GeminiChat, prompt_id: string, agentId?: string, providerName?: string);
    /**
     * Check if citations should be shown for the current user/settings.
     * Based on the upstream implementation from commit 997136ae.
     */
    private shouldShowCitations;
    /**
     * Emits a citation event with the given text.
     * This integrates with llxprt's provider abstraction to work across all providers.
     */
    private emitCitation;
    run(req: PartListUnion, signal: AbortSignal): AsyncGenerator<ServerGeminiStreamEvent>;
    private handlePendingFunctionCall;
    getDebugResponses(): GenerateContentResponse[];
}