/**
 * @license
 * Copyright 2025 OSAgent OC
 * SPDX-License-Identifier: Apache-2.0
 */
import type { Part, PartListUnion, GenerateContentResponse, FunctionDeclaration, FinishReason, GenerateContentResponseUsageMetadata } from '@google/genai';
import type { ToolCallConfirmationDetails, ToolResult, ToolResultDisplay } from '../tools/tools.js';
import type { ToolErrorType } from '../tools/tool-error.js';
import type { OSAChat } from './geminiChat.js';
import { type ThoughtSummary } from '../utils/thoughtUtils.js';
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 OSAEventType {
    Content = "content",
    ToolCallRequest = "tool_call_request",
    ToolCallResponse = "tool_call_response",
    ToolCallConfirmation = "tool_call_confirmation",
    UserCancelled = "user_cancelled",
    Error = "error",
    ChatCompressed = "chat_compressed",
    Thought = "thought",
    MaxSessionTurns = "max_session_turns",
    SessionTokenLimitExceeded = "session_token_limit_exceeded",
    Finished = "finished",
    LoopDetected = "loop_detected",
    Citation = "citation",
    Retry = "retry"
}
export type ServerOSARetryEvent = {
    type: OSAEventType.Retry;
};
export interface StructuredError {
    message: string;
    status?: number;
}
export interface OSAErrorEventValue {
    error: StructuredError;
}
export interface SessionTokenLimitExceededValue {
    currentTokens: number;
    limit: number;
    message: string;
}
export interface OSAFinishedEventValue {
    reason: FinishReason | undefined;
    usageMetadata: GenerateContentResponseUsageMetadata | undefined;
}
export interface ToolCallRequestInfo {
    callId: string;
    name: string;
    args: Record<string, unknown>;
    isClientInitiated: boolean;
    prompt_id: string;
    response_id?: string;
}
export interface ToolCallResponseInfo {
    callId: string;
    responseParts: Part[];
    resultDisplay: ToolResultDisplay | undefined;
    error: Error | undefined;
    errorType: ToolErrorType | undefined;
    outputFile?: string | undefined;
    contentLength?: number;
}
export interface ServerToolCallConfirmationDetails {
    request: ToolCallRequestInfo;
    details: ToolCallConfirmationDetails;
}
export type ServerOSAContentEvent = {
    type: OSAEventType.Content;
    value: string;
};
export type ServerOSAThoughtEvent = {
    type: OSAEventType.Thought;
    value: ThoughtSummary;
};
export type ServerOSAToolCallRequestEvent = {
    type: OSAEventType.ToolCallRequest;
    value: ToolCallRequestInfo;
};
export type ServerOSAToolCallResponseEvent = {
    type: OSAEventType.ToolCallResponse;
    value: ToolCallResponseInfo;
};
export type ServerOSAToolCallConfirmationEvent = {
    type: OSAEventType.ToolCallConfirmation;
    value: ServerToolCallConfirmationDetails;
};
export type ServerOSAUserCancelledEvent = {
    type: OSAEventType.UserCancelled;
};
export type ServerOSAErrorEvent = {
    type: OSAEventType.Error;
    value: OSAErrorEventValue;
};
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 failed due to receiving an empty or null summary */
    COMPRESSION_FAILED_EMPTY_SUMMARY = 4,
    /** The compression was not necessary and no action was taken */
    NOOP = 5
}
export interface ChatCompressionInfo {
    originalTokenCount: number;
    newTokenCount: number;
    compressionStatus: CompressionStatus;
}
export type ServerOSAChatCompressedEvent = {
    type: OSAEventType.ChatCompressed;
    value: ChatCompressionInfo | null;
};
export type ServerOSAMaxSessionTurnsEvent = {
    type: OSAEventType.MaxSessionTurns;
};
export type ServerOSASessionTokenLimitExceededEvent = {
    type: OSAEventType.SessionTokenLimitExceeded;
    value: SessionTokenLimitExceededValue;
};
export type ServerOSAFinishedEvent = {
    type: OSAEventType.Finished;
    value: OSAFinishedEventValue;
};
export type ServerOSALoopDetectedEvent = {
    type: OSAEventType.LoopDetected;
};
export type ServerOSACitationEvent = {
    type: OSAEventType.Citation;
    value: string;
};
export type ServerOSAStreamEvent = ServerOSAChatCompressedEvent | ServerOSACitationEvent | ServerOSAContentEvent | ServerOSAErrorEvent | ServerOSAFinishedEvent | ServerOSALoopDetectedEvent | ServerOSAMaxSessionTurnsEvent | ServerOSAThoughtEvent | ServerOSAToolCallConfirmationEvent | ServerOSAToolCallRequestEvent | ServerOSAToolCallResponseEvent | ServerOSAUserCancelledEvent | ServerOSASessionTokenLimitExceededEvent | ServerOSARetryEvent;
export declare class Turn {
    private readonly chat;
    private readonly prompt_id;
    readonly pendingToolCalls: ToolCallRequestInfo[];
    private debugResponses;
    private pendingCitations;
    finishReason: FinishReason | undefined;
    private currentResponseId?;
    constructor(chat: OSAChat, prompt_id: string);
    run(model: string, req: PartListUnion, signal: AbortSignal): AsyncGenerator<ServerOSAStreamEvent>;
    private handlePendingFunctionCall;
    getDebugResponses(): GenerateContentResponse[];
}