import { AIServiceType, ActionSourceEnum, ActionTypeEnum, CancellationToken, Event, IChatComponent, IChatContent, IChatProgress, IDisposable, IMarkdownString, Uri } from '@opensumi/ide-core-common';
import { IPosition, ITextModel, InlineCompletionContext } from '@opensumi/ide-monaco/lib/common';
import { IMCPServer, MCPServerDescription } from './mcp-server-manager';
import { IPartialEditEvent, MCPTool } from './types';
import type { CoreMessage } from 'ai';
export type { CoreMessage };
export * from './model';
export declare const IAINativeService: unique symbol;
/**
 * @deprecated Use {@link AIInlineChatContentWidgetId} instead
 */
export declare const AIInlineChatContentWidget = "AI-Inline-Chat-Content-Widget";
export declare const AI_CHAT_VIEW_ID = "AI-Chat";
export declare const AI_CHAT_CONTAINER_ID = "AI-Chat-Container";
export declare const AI_CHAT_LOGO_AVATAR_ID = "AI-Chat-Logo-Avatar";
export declare const AI_MENU_BAR_DEBUG_TOOLBAR = "AI_MENU_BAR_DEBUG_TOOLBAR";
export declare const BUILTIN_MCP_SERVER_NAME = "Builtin";
/**
 * @deprecated Use {@link DESIGN_MENUBAR_CONTAINER_VIEW_ID} instead
 */
export declare const AI_MENUBAR_CONTAINER_VIEW_ID = "design_menubar";
export declare const SLASH_SYMBOL = "/";
export declare const AT_SIGN_SYMBOL = "@";
export interface IChatMessageStructure {
    /**
     * 用于 chat 面板展示
     */
    message: string;
    /**
     * 图片
     */
    images?: string[];
    /**
     * 实际调用的 prompt
     */
    prompt?: string;
    /**
     * 数据采集上报消息类型
     */
    reportType?: AIServiceType;
    agentId?: string;
    /**
     * slash command
     */
    command?: string;
    /**
     * 是否立即发送，默认为 true
     */
    immediate?: boolean;
    /**
     * 上报数据时需要增加额外的字段
     */
    reportExtra?: {
        actionType?: ActionTypeEnum | string;
        actionSource?: ActionSourceEnum | string;
    };
}
export interface IChatMessageListUserItem {
    role: 'user';
    message: string;
}
export type IChatMessageListAssistantItem = (IChatComponent | IChatContent) & {
    role: 'assistant';
};
export type IChatMessageListItem = IChatMessageListUserItem | IChatMessageListAssistantItem;
export declare enum ChatCompletionRequestMessageRoleEnum {
    System = "system",
    User = "user",
    Assistant = "assistant"
}
export interface ChatCompletionRequestMessage {
    /**
     * The role of the author of this message.
     * @type {string}
     * @memberof ChatCompletionRequestMessage
     */
    role: ChatCompletionRequestMessageRoleEnum;
    /**
     * The contents of the message
     * @type {string}
     * @memberof ChatCompletionRequestMessage
     */
    content: string;
    /**
     * The name of the user in a multi-user chat
     * @type {string}
     * @memberof ChatCompletionRequestMessage
     */
    name?: string;
}
export declare const IChatInternalService: unique symbol;
export declare const IChatManagerService: unique symbol;
export declare const IChatAgentService: unique symbol;
export declare const ChatProxyServiceToken: unique symbol;
export declare const TokenMCPServerProxyService: unique symbol;
export interface ISumiMCPServerBackend {
    $initBuiltinMCPServer(enabled: boolean): void;
    $initExternalMCPServers(servers: MCPServerDescription[]): void;
    $getAllMCPTools(): Promise<MCPTool[]>;
    $getServers(): Promise<Array<{
        name: string;
        isStarted: boolean;
        type: string;
        tools: MCPTool[];
    }>>;
    $startServer(serverName: string): Promise<void>;
    $stopServer(serverName: string): Promise<void>;
    $addOrUpdateServer(description: MCPServerDescription): void;
    $removeServer(name: string): void;
    $syncServer(name: string): Promise<void>;
    $getMCPServerByName(name: string): IMCPServer | undefined;
}
export declare const SumiMCPServerProxyServicePath = "SumiMCPServerProxyServicePath";
export interface IChatAgentService {
    readonly onDidChangeAgents: Event<void>;
    readonly onDidSendMessage: Event<IChatProgress>;
    registerAgent(agent: IChatAgent): IDisposable;
    invokeAgent(id: string, request: IChatAgentRequest, progress: (part: IChatProgress) => void, history: CoreMessage[], token: CancellationToken): Promise<IChatAgentResult>;
    getAgents(): Array<IChatAgent>;
    getAgent(id: string): IChatAgent | undefined;
    hasAgent(id: string): boolean;
    updateAgent(id: string, updateMetadata: IChatAgentMetadata): Promise<void>;
    populateChatInput(id: string, message: IChatMessageStructure): void;
    getCommands(): Array<IChatAgentCommand & {
        agentId: string;
    }>;
    parseMessage(value: string, currentAgentId?: string): {
        agentId: string;
        command: string;
        message: string;
    };
    getFollowups(id: string, sessionId: string, token: CancellationToken): Promise<IChatFollowup[]>;
    getSampleQuestions(id: string, token: CancellationToken): Promise<IChatFollowup[]>;
    getAllSampleQuestions(): Promise<IChatReplyFollowup[]>;
    getDefaultAgentId(): undefined | string;
    sendMessage(chunk: IChatProgress): void;
}
export interface IChatAgent extends IChatAgentData {
    invoke(request: IChatAgentRequest, progress: (part: IChatProgress) => void, history: CoreMessage[], token: CancellationToken): Promise<IChatAgentResult>;
    provideFollowups?(sessionId: string, token: CancellationToken): Promise<IChatFollowup[]>;
    provideSlashCommands(token: CancellationToken): Promise<IChatAgentCommand[]>;
    provideSampleQuestions?(token: CancellationToken): Promise<IChatReplyFollowup[]>;
    provideChatWelcomeMessage(token: CancellationToken): Promise<undefined | IChatAgentWelcomeMessage>;
}
export interface IChatAgentData {
    id: string;
    metadata: IChatAgentMetadata;
}
export interface IChatAgentMetadata {
    description?: string;
    isDefault?: boolean;
    fullName?: string;
    icon?: Uri;
    iconDark?: Uri;
    systemPrompt?: string;
}
export interface IChatAgentRequest {
    sessionId: string;
    requestId: string;
    command?: string;
    message: string;
    images?: string[];
    regenerate?: boolean;
}
export interface IChatResponseErrorDetails {
    message: string;
}
export interface IChatAgentResult {
    errorDetails?: IChatResponseErrorDetails;
}
export interface IChatAgentCommand {
    name: string;
    description: string;
    isShortcut?: true;
}
export interface IChatReplyFollowup {
    kind: 'reply';
    message: string;
    title?: string;
    tooltip?: string;
}
export interface IChatResponseCommandFollowup {
    kind: 'command';
    commandId: string;
    args?: any[];
    title: string;
    when?: string;
}
export type IChatFollowup = IChatReplyFollowup | IChatResponseCommandFollowup;
export interface IChatRequestMessage {
    prompt: string;
    images?: string[];
    agentId: string;
    command?: string;
}
export interface IChatRequestModel {
    readonly requestId: string;
    session: IChatModel;
    message: IChatRequestMessage;
    response: IChatResponseModel;
}
export interface IChatResponseModel {
    readonly requestId: string;
    session: IChatModel;
}
export interface IChatModel {
    readonly requests: IChatRequestModel[];
}
export type IChatWelcomeMessageContent = string | IMarkdownString;
export interface ISampleQuestions {
    message: string;
    title?: string;
    icon?: string;
    tooltip?: string;
}
export interface IChatAgentWelcomeMessage {
    content: IChatWelcomeMessageContent;
    sampleQuestions?: IChatReplyFollowup[];
}
/**
 * Terminal type
 */
export interface ITerminalCommandSuggestionDesc {
    description: string;
    command: string;
}
export declare enum EInlineChatStatus {
    READY = 0,
    THINKING = 1,
    DONE = 2,
    ERROR = 3
}
export declare enum EResultKind {
    ACCEPT = "ACCEPT",
    DISCARD = "DISCARD",
    REGENERATE = "REGENERATE"
}
export declare const IAIInlineCompletionsProvider: unique symbol;
export interface IAIInlineCompletionsProvider {
    hideStatusBarItem(): void;
    cancelRequest(): void;
    isDelEvent: boolean;
    provideInlineCompletionItems<T>(model: ITextModel, position: IPosition, context: InlineCompletionContext, token: CancellationToken): Promise<T>;
    setVisibleCompletion(arg0: boolean): void;
}
export interface IInlineDiffService {
    onPartialEdit: Event<IPartialEditEvent>;
    firePartialEdit(event: IPartialEditEvent): void;
}
export declare const InlineDiffServiceToken: unique symbol;
//# sourceMappingURL=index.d.ts.map