@xiuper/mpp-core 0.0.2

package/autodev-mpp-core.d.ts

@@ -0,0 +1,1312 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare namespace kotlin.collections {
+    interface KtMap<K, V> {
+        asJsReadonlyMapView(): ReadonlyMap<K, V>;
+        readonly __doNotUseOrImplementIt: {
+            readonly "kotlin.collections.KtMap": unique symbol;
+        };
+    }
+    abstract class KtMap<K, V> extends KtSingleton<KtMap.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace KtMap.$metadata$ {
+        abstract class constructor {
+            fromJsMap<K, V>(map: ReadonlyMap<K, V>): kotlin.collections.KtMap<K, V>;
+            private constructor();
+        }
+    }
+}
+export declare namespace io.ktor.client.engine.js {
+    /** @deprecated  */
+    const initHook: any;
+}
+export declare namespace cc.unitmesh.agent {
+    class JsReviewTask {
+        constructor(filePaths: Array<string>, reviewType: string | undefined, projectPath: string, additionalContext?: string);
+        get filePaths(): Array<string>;
+        get reviewType(): string;
+        get projectPath(): string;
+        get additionalContext(): string;
+        toCommon(): any/* cc.unitmesh.agent.ReviewTask */;
+        copy(filePaths?: Array<string>, reviewType?: string, projectPath?: string, additionalContext?: string): cc.unitmesh.agent.JsReviewTask;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsReviewTask.$metadata$ {
+        const constructor: abstract new () => JsReviewTask;
+    }
+    class JsReviewFinding {
+        constructor(severity: string, category: string, description: string, filePath?: Nullable<string>, lineNumber?: Nullable<number>, suggestion?: Nullable<string>);
+        get severity(): string;
+        get category(): string;
+        get description(): string;
+        get filePath(): Nullable<string>;
+        get lineNumber(): Nullable<number>;
+        get suggestion(): Nullable<string>;
+        copy(severity?: string, category?: string, description?: string, filePath?: Nullable<string>, lineNumber?: Nullable<number>, suggestion?: Nullable<string>): cc.unitmesh.agent.JsReviewFinding;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsReviewFinding.$metadata$ {
+        const constructor: abstract new () => JsReviewFinding;
+    }
+    namespace JsReviewFinding {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                fromCommon(finding: any/* cc.unitmesh.agent.ReviewFinding */): cc.unitmesh.agent.JsReviewFinding;
+                private constructor();
+            }
+        }
+    }
+    class JsCodeReviewResult {
+        constructor(success: boolean, message: string, findings: Array<cc.unitmesh.agent.JsReviewFinding>);
+        get success(): boolean;
+        get message(): string;
+        get findings(): Array<cc.unitmesh.agent.JsReviewFinding>;
+        copy(success?: boolean, message?: string, findings?: Array<cc.unitmesh.agent.JsReviewFinding>): cc.unitmesh.agent.JsCodeReviewResult;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsCodeReviewResult.$metadata$ {
+        const constructor: abstract new () => JsCodeReviewResult;
+    }
+    namespace JsCodeReviewResult {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                fromCommon(result: any/* cc.unitmesh.agent.CodeReviewResult */): cc.unitmesh.agent.JsCodeReviewResult;
+                private constructor();
+            }
+        }
+    }
+    class JsLintResult {
+        constructor(filePath: string, issues: Array<cc.unitmesh.agent.JsLintIssue>, success: boolean, errorMessage?: Nullable<string>);
+        get filePath(): string;
+        get issues(): Array<cc.unitmesh.agent.JsLintIssue>;
+        get success(): boolean;
+        get errorMessage(): Nullable<string>;
+        copy(filePath?: string, issues?: Array<cc.unitmesh.agent.JsLintIssue>, success?: boolean, errorMessage?: Nullable<string>): cc.unitmesh.agent.JsLintResult;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsLintResult.$metadata$ {
+        const constructor: abstract new () => JsLintResult;
+    }
+    class JsLintIssue {
+        constructor(line: number, column: number, severity: string, message: string, rule?: Nullable<string>, suggestion?: Nullable<string>);
+        get line(): number;
+        get column(): number;
+        get severity(): string;
+        get message(): string;
+        get rule(): Nullable<string>;
+        get suggestion(): Nullable<string>;
+        copy(line?: number, column?: number, severity?: string, message?: string, rule?: Nullable<string>, suggestion?: Nullable<string>): cc.unitmesh.agent.JsLintIssue;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsLintIssue.$metadata$ {
+        const constructor: abstract new () => JsLintIssue;
+    }
+    class JsLintFileResult {
+        constructor(filePath: string, linterName: string, errorCount: number, warningCount: number, infoCount: number, issues: Array<cc.unitmesh.agent.JsLintIssue>);
+        get filePath(): string;
+        get linterName(): string;
+        get errorCount(): number;
+        get warningCount(): number;
+        get infoCount(): number;
+        get issues(): Array<cc.unitmesh.agent.JsLintIssue>;
+        copy(filePath?: string, linterName?: string, errorCount?: number, warningCount?: number, infoCount?: number, issues?: Array<cc.unitmesh.agent.JsLintIssue>): cc.unitmesh.agent.JsLintFileResult;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsLintFileResult.$metadata$ {
+        const constructor: abstract new () => JsLintFileResult;
+    }
+    class JsCodeReviewAgent {
+        constructor(projectPath: string, llmService: cc.unitmesh.llm.JsKoogLLMService, maxIterations?: number, renderer?: Nullable<cc.unitmesh.agent.JsCodingAgentRenderer>, mcpServers?: any, toolConfig?: Nullable<cc.unitmesh.agent.config.JsToolConfigFile>);
+        executeTask(reviewType: string, filePaths?: Array<string>, codeContent?: any, lintResults?: any, diffContext?: string, commitMessage?: string, commitId?: string, repoUrl?: string, issueToken?: string, useTools?: boolean, analyzeIntent?: boolean, language?: string, onChunk?: Nullable<(p0: string) => void>): Promise<cc.unitmesh.agent.JsAnalysisResult>;
+        generateFixes(patch: string, lintResults: Array<cc.unitmesh.agent.JsLintFileResult>, analysisOutput: string, language?: string, onChunk?: Nullable<(p0: string) => void>): Promise<string>;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsCodeReviewAgent.$metadata$ {
+        const constructor: abstract new () => JsCodeReviewAgent;
+    }
+    class JsAnalysisResult {
+        constructor(success: boolean, content: string, mermaidDiagram: Nullable<string>, issuesAnalyzed: Array<string>, usedTools: boolean);
+        get success(): boolean;
+        get content(): string;
+        get mermaidDiagram(): Nullable<string>;
+        get issuesAnalyzed(): Array<string>;
+        get usedTools(): boolean;
+        copy(success?: boolean, content?: string, mermaidDiagram?: Nullable<string>, issuesAnalyzed?: Array<string>, usedTools?: boolean): cc.unitmesh.agent.JsAnalysisResult;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsAnalysisResult.$metadata$ {
+        const constructor: abstract new () => JsAnalysisResult;
+    }
+    class JsDiffFile {
+        constructor(path: string, oldPath: Nullable<string>, changeType: string, addedLines: number, deletedLines: number, hunks: Array<cc.unitmesh.agent.JsDiffHunk>);
+        get path(): string;
+        get oldPath(): Nullable<string>;
+        get changeType(): string;
+        get addedLines(): number;
+        get deletedLines(): number;
+        get hunks(): Array<cc.unitmesh.agent.JsDiffHunk>;
+        copy(path?: string, oldPath?: Nullable<string>, changeType?: string, addedLines?: number, deletedLines?: number, hunks?: Array<cc.unitmesh.agent.JsDiffHunk>): cc.unitmesh.agent.JsDiffFile;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDiffFile.$metadata$ {
+        const constructor: abstract new () => JsDiffFile;
+    }
+    class JsDiffHunk {
+        constructor(oldStartLine: number, oldLineCount: number, newStartLine: number, newLineCount: number, header: string, addedLines: Array<string>, deletedLines: Array<string>, contextLines: Array<string>);
+        get oldStartLine(): number;
+        get oldLineCount(): number;
+        get newStartLine(): number;
+        get newLineCount(): number;
+        get header(): string;
+        get addedLines(): Array<string>;
+        get deletedLines(): Array<string>;
+        get contextLines(): Array<string>;
+        copy(oldStartLine?: number, oldLineCount?: number, newStartLine?: number, newLineCount?: number, header?: string, addedLines?: Array<string>, deletedLines?: Array<string>, contextLines?: Array<string>): cc.unitmesh.agent.JsDiffHunk;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDiffHunk.$metadata$ {
+        const constructor: abstract new () => JsDiffHunk;
+    }
+    abstract class JsDiffUtils extends KtSingleton<JsDiffUtils.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDiffUtils.$metadata$ {
+        abstract class constructor {
+            parseDiff(diffContent: string): Array<cc.unitmesh.agent.JsDiffFile>;
+            extractFilePaths(diffContent: string): Array<string>;
+            private constructor();
+        }
+    }
+    class JsLinterRegistry {
+        constructor();
+        findLintersForFiles(filePaths: Array<string>): Array<string>;
+        detectLanguage(filePath: string): Nullable<string>;
+        getLintersForLanguage(language: string): Array<string>;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsLinterRegistry.$metadata$ {
+        const constructor: abstract new () => JsLinterRegistry;
+    }
+}
+export declare namespace cc.unitmesh.agent {
+    class JsAgentStep {
+        constructor(step: number, action: string, tool: Nullable<string> | undefined, params: Nullable<string> | undefined, result: Nullable<string> | undefined, success: boolean);
+        get step(): number;
+        get action(): string;
+        get tool(): Nullable<string>;
+        get params(): Nullable<string>;
+        get result(): Nullable<string>;
+        get success(): boolean;
+        copy(step?: number, action?: string, tool?: Nullable<string>, params?: Nullable<string>, result?: Nullable<string>, success?: boolean): cc.unitmesh.agent.JsAgentStep;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsAgentStep.$metadata$ {
+        const constructor: abstract new () => JsAgentStep;
+    }
+    namespace JsAgentStep {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                fromCommon(step: any/* cc.unitmesh.agent.AgentStep */): cc.unitmesh.agent.JsAgentStep;
+                private constructor();
+            }
+        }
+    }
+    class JsAgentEdit {
+        constructor(file: string, operation: string, content?: Nullable<string>);
+        get file(): string;
+        get operation(): string;
+        get content(): Nullable<string>;
+        copy(file?: string, operation?: string, content?: Nullable<string>): cc.unitmesh.agent.JsAgentEdit;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsAgentEdit.$metadata$ {
+        const constructor: abstract new () => JsAgentEdit;
+    }
+    namespace JsAgentEdit {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                fromCommon(edit: any/* cc.unitmesh.agent.AgentEdit */): cc.unitmesh.agent.JsAgentEdit;
+                private constructor();
+            }
+        }
+    }
+    class JsAgentResult {
+        constructor(success: boolean, message: string, steps: Array<cc.unitmesh.agent.JsAgentStep>, edits: Array<cc.unitmesh.agent.JsAgentEdit>);
+        get success(): boolean;
+        get message(): string;
+        get steps(): Array<cc.unitmesh.agent.JsAgentStep>;
+        get edits(): Array<cc.unitmesh.agent.JsAgentEdit>;
+        copy(success?: boolean, message?: string, steps?: Array<cc.unitmesh.agent.JsAgentStep>, edits?: Array<cc.unitmesh.agent.JsAgentEdit>): cc.unitmesh.agent.JsAgentResult;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsAgentResult.$metadata$ {
+        const constructor: abstract new () => JsAgentResult;
+    }
+    namespace JsAgentResult {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                fromCommon(result: any/* cc.unitmesh.agent.AgentResult */): cc.unitmesh.agent.JsAgentResult;
+                private constructor();
+            }
+        }
+    }
+    class JsAgentTask {
+        constructor(requirement: string, projectPath: string, language?: string);
+        get requirement(): string;
+        get projectPath(): string;
+        get language(): string;
+        toCommon(): any/* cc.unitmesh.agent.AgentTask */;
+        copy(requirement?: string, projectPath?: string, language?: string): cc.unitmesh.agent.JsAgentTask;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsAgentTask.$metadata$ {
+        const constructor: abstract new () => JsAgentTask;
+    }
+    class JsCodingAgent {
+        constructor(projectPath: string, llmService: cc.unitmesh.llm.JsKoogLLMService, maxIterations?: number, renderer?: Nullable<cc.unitmesh.agent.JsCodingAgentRenderer>, mcpServers?: any, toolConfig?: Nullable<cc.unitmesh.agent.config.JsToolConfigFile>);
+        executeTask(task: cc.unitmesh.agent.JsAgentTask): Promise<cc.unitmesh.agent.JsAgentResult>;
+        initializeWorkspace(): Promise<void>;
+        getConversationHistory(): Array<cc.unitmesh.llm.JsMessage>;
+        observePlanState(callback: (p0: Nullable<cc.unitmesh.agent.JsPlanSummaryData>) => void): () => void;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsCodingAgent.$metadata$ {
+        const constructor: abstract new () => JsCodingAgent;
+    }
+}
+export declare namespace cc.unitmesh.agent {
+    class JsDocumentTask {
+        constructor(query: string, documentPath?: Nullable<string>);
+        get query(): string;
+        get documentPath(): Nullable<string>;
+        toCommon(): any/* cc.unitmesh.agent.document.DocumentTask */;
+        copy(query?: string, documentPath?: Nullable<string>): cc.unitmesh.agent.JsDocumentTask;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDocumentTask.$metadata$ {
+        const constructor: abstract new () => JsDocumentTask;
+    }
+    class JsDocumentResult {
+        constructor(success: boolean, message: string);
+        get success(): boolean;
+        get message(): string;
+        copy(success?: boolean, message?: string): cc.unitmesh.agent.JsDocumentResult;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDocumentResult.$metadata$ {
+        const constructor: abstract new () => JsDocumentResult;
+    }
+    class JsDocumentAgent {
+        constructor(llmService: cc.unitmesh.llm.JsKoogLLMService, parserService: any/* cc.unitmesh.devins.document.DocumentParserService */, renderer?: Nullable<cc.unitmesh.agent.JsCodingAgentRenderer>, toolConfig?: Nullable<cc.unitmesh.agent.config.JsToolConfigFile>);
+        executeTask(query: string, documentPath?: Nullable<string>, onChunk?: Nullable<(p0: string) => void>): Promise<cc.unitmesh.agent.JsDocumentResult>;
+        registerDocument(path: string, content: string): Promise<boolean>;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDocumentAgent.$metadata$ {
+        const constructor: abstract new () => JsDocumentAgent;
+    }
+}
+export declare namespace cc.unitmesh.agent {
+    class JsDomainDictContext {
+        constructor(userQuery: string, currentDict?: Nullable<string>, maxIterations?: number, focusArea?: Nullable<string>);
+        get userQuery(): string;
+        get currentDict(): Nullable<string>;
+        get maxIterations(): number;
+        get focusArea(): Nullable<string>;
+        toCommon(): any/* cc.unitmesh.agent.subagent.DomainDictContext */;
+        copy(userQuery?: string, currentDict?: Nullable<string>, maxIterations?: number, focusArea?: Nullable<string>): cc.unitmesh.agent.JsDomainDictContext;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDomainDictContext.$metadata$ {
+        const constructor: abstract new () => JsDomainDictContext;
+    }
+    class JsDeepResearchResult {
+        constructor(success: boolean, message: string, steps: number, newEntries: number, report: string);
+        get success(): boolean;
+        get message(): string;
+        get steps(): number;
+        get newEntries(): number;
+        get report(): string;
+        copy(success?: boolean, message?: string, steps?: number, newEntries?: number, report?: string): cc.unitmesh.agent.JsDeepResearchResult;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDeepResearchResult.$metadata$ {
+        const constructor: abstract new () => JsDeepResearchResult;
+    }
+    class JsDomainDictAgent {
+        constructor(projectPath: string, llmService: cc.unitmesh.llm.JsKoogLLMService);
+        executeDeepResearch(userQuery: string, focusArea?: Nullable<string>, maxIterations?: number, onProgress?: Nullable<(p0: string) => void>): Promise<cc.unitmesh.agent.JsDeepResearchResult>;
+        executeQuickResearch(userQuery: string, focusArea?: Nullable<string>, onProgress?: Nullable<(p0: string) => void>): Promise<cc.unitmesh.agent.JsDeepResearchResult>;
+        dictionaryExists(): Promise<boolean>;
+        getDictionaryContent(): Promise<Nullable<string>>;
+        getStateSummary(): any;
+        askQuestion(question: string): Promise<string>;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDomainDictAgent.$metadata$ {
+        const constructor: abstract new () => JsDomainDictAgent;
+    }
+    namespace JsDomainDictAgent {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                create(projectPath: string, llmService: cc.unitmesh.llm.JsKoogLLMService): cc.unitmesh.agent.JsDomainDictAgent;
+                private constructor();
+            }
+        }
+    }
+}
+export declare namespace cc.unitmesh.agent {
+    abstract class JsPlatform extends KtSingleton<JsPlatform.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsPlatform.$metadata$ {
+        abstract class constructor {
+            get name(): string;
+            get isJvm(): boolean;
+            get isJs(): boolean;
+            get isWasm(): boolean;
+            get isAndroid(): boolean;
+            get isIOS(): boolean;
+            getOSName(): string;
+            getDefaultShell(): string;
+            getCurrentTimestamp(): string;
+            getOSInfo(): string;
+            getOSVersion(): string;
+            getUserHomeDir(): string;
+            getLogDir(): string;
+            private constructor();
+        }
+    }
+    function getPlatformInfo(): string;
+}
+export declare namespace cc.unitmesh.agent {
+    class JsStepSummary {
+        constructor(id: string, description: string, status: string);
+        get id(): string;
+        get description(): string;
+        get status(): string;
+        copy(id?: string, description?: string, status?: string): cc.unitmesh.agent.JsStepSummary;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsStepSummary.$metadata$ {
+        const constructor: abstract new () => JsStepSummary;
+    }
+    namespace JsStepSummary {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                from(step: any/* cc.unitmesh.agent.plan.StepSummary */): cc.unitmesh.agent.JsStepSummary;
+                private constructor();
+            }
+        }
+    }
+    class JsTaskSummary {
+        constructor(id: string, title: string, status: string, completedSteps: number, totalSteps: number, steps: Array<cc.unitmesh.agent.JsStepSummary>);
+        get id(): string;
+        get title(): string;
+        get status(): string;
+        get completedSteps(): number;
+        get totalSteps(): number;
+        get steps(): Array<cc.unitmesh.agent.JsStepSummary>;
+        copy(id?: string, title?: string, status?: string, completedSteps?: number, totalSteps?: number, steps?: Array<cc.unitmesh.agent.JsStepSummary>): cc.unitmesh.agent.JsTaskSummary;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsTaskSummary.$metadata$ {
+        const constructor: abstract new () => JsTaskSummary;
+    }
+    namespace JsTaskSummary {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                from(task: any/* cc.unitmesh.agent.plan.TaskSummary */): cc.unitmesh.agent.JsTaskSummary;
+                private constructor();
+            }
+        }
+    }
+    class JsPlanSummaryData {
+        constructor(planId: string, title: string, totalSteps: number, completedSteps: number, failedSteps: number, progressPercent: number, status: string, currentStepDescription: Nullable<string>, tasks: Array<cc.unitmesh.agent.JsTaskSummary>);
+        get planId(): string;
+        get title(): string;
+        get totalSteps(): number;
+        get completedSteps(): number;
+        get failedSteps(): number;
+        get progressPercent(): number;
+        get status(): string;
+        get currentStepDescription(): Nullable<string>;
+        get tasks(): Array<cc.unitmesh.agent.JsTaskSummary>;
+        copy(planId?: string, title?: string, totalSteps?: number, completedSteps?: number, failedSteps?: number, progressPercent?: number, status?: string, currentStepDescription?: Nullable<string>, tasks?: Array<cc.unitmesh.agent.JsTaskSummary>): cc.unitmesh.agent.JsPlanSummaryData;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsPlanSummaryData.$metadata$ {
+        const constructor: abstract new () => JsPlanSummaryData;
+    }
+    namespace JsPlanSummaryData {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                from(summary: any/* cc.unitmesh.agent.plan.PlanSummaryData */): cc.unitmesh.agent.JsPlanSummaryData;
+                private constructor();
+            }
+        }
+    }
+    interface JsCodingAgentRenderer {
+        renderIterationHeader(current: number, max: number): void;
+        renderLLMResponseStart(): void;
+        renderLLMResponseChunk(chunk: string): void;
+        renderLLMResponseEnd(): void;
+        renderToolCall(toolName: string, paramsStr: string): void;
+        renderToolResult(toolName: string, success: boolean, output: Nullable<string>, fullOutput: Nullable<string>): void;
+        renderTaskComplete(executionTimeMs?: number, toolsUsedCount?: number): void;
+        renderFinalResult(success: boolean, message: string, iterations: number): void;
+        renderError(message: string): void;
+        renderRepeatWarning(toolName: string, count: number): void;
+        renderRecoveryAdvice(recoveryAdvice: string): void;
+        renderPlanSummary(summary: cc.unitmesh.agent.JsPlanSummaryData): void;
+        renderAgentSketchBlock(agentName: string, language: string, code: string, metadata: any): void;
+        readonly __doNotUseOrImplementIt: {
+            readonly "cc.unitmesh.agent.JsCodingAgentRenderer": unique symbol;
+        };
+    }
+    abstract class RendererFactory extends KtSingleton<RendererFactory.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace RendererFactory.$metadata$ {
+        abstract class constructor {
+            createRenderer(jsRenderer: cc.unitmesh.agent.JsCodingAgentRenderer): any/* cc.unitmesh.agent.render.CodingAgentRenderer */;
+            private constructor();
+        }
+    }
+}
+export declare namespace cc.unitmesh.agent.config {
+    abstract class JsToolConfigManager extends KtSingleton<JsToolConfigManager.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsToolConfigManager.$metadata$ {
+        abstract class constructor {
+            loadToolConfig(): Promise<cc.unitmesh.agent.config.JsToolConfigFile>;
+            saveToolConfig(config: cc.unitmesh.agent.config.JsToolConfigFile): Promise<void>;
+            getConfigSummary(config: cc.unitmesh.agent.config.JsToolConfigFile): string;
+            updateToolConfig(currentConfig: cc.unitmesh.agent.config.JsToolConfigFile, enabledBuiltinTools: Array<string>, enabledMcpTools: Array<string>): cc.unitmesh.agent.config.JsToolConfigFile;
+            private constructor();
+        }
+    }
+    class JsToolConfigFile {
+        constructor(enabledBuiltinTools: Array<string>, enabledMcpTools: Array<string>, mcpServers: any);
+        get enabledBuiltinTools(): Array<string>;
+        get enabledMcpTools(): Array<string>;
+        get mcpServers(): any;
+        toCommon(): any/* cc.unitmesh.agent.config.ToolConfigFile */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsToolConfigFile.$metadata$ {
+        const constructor: abstract new () => JsToolConfigFile;
+    }
+    namespace JsToolConfigFile {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                fromCommon(config: any/* cc.unitmesh.agent.config.ToolConfigFile */): cc.unitmesh.agent.config.JsToolConfigFile;
+                default(): cc.unitmesh.agent.config.JsToolConfigFile;
+                private constructor();
+            }
+        }
+    }
+    class JsChatConfig {
+        constructor(temperature: number, systemPrompt: string, maxTokens: number);
+        get temperature(): number;
+        get systemPrompt(): string;
+        get maxTokens(): number;
+        toCommon(): any/* cc.unitmesh.agent.config.ChatConfig */;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsChatConfig.$metadata$ {
+        const constructor: abstract new () => JsChatConfig;
+    }
+    namespace JsChatConfig {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                fromCommon(config: any/* cc.unitmesh.agent.config.ChatConfig */): cc.unitmesh.agent.config.JsChatConfig;
+                private constructor();
+            }
+        }
+    }
+}
+export declare namespace cc.unitmesh.agent.linter {
+    abstract class JsLinterRegistry extends KtSingleton<JsLinterRegistry.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsLinterRegistry.$metadata$ {
+        abstract class constructor {
+            getLinterSummaryForFiles(filePaths: Array<string>, projectPath?: string): Promise<cc.unitmesh.agent.linter.JsLinterSummary>;
+            findLintersForFiles(filePaths: Array<string>): Array<string>;
+            getAllLinters(): Array<string>;
+            private constructor();
+        }
+    }
+    class JsLintDetector {
+        constructor(projectPath: string);
+        detectAvailableLinters(): Promise<Array<cc.unitmesh.agent.linter.JsLinterDetectionResult>>;
+        detectLintersForFiles(filePaths: Array<string>): Promise<Array<cc.unitmesh.agent.linter.JsLinterDetectionResult>>;
+        getLinterConfig(name: string): Nullable<cc.unitmesh.agent.linter.JsLinterConfig>;
+        getAllLinterConfigs(): Array<cc.unitmesh.agent.linter.JsLinterConfig>;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsLintDetector.$metadata$ {
+        const constructor: abstract new () => JsLintDetector;
+    }
+    class JsLinterDetectionResult {
+        constructor(linterName: string, isAvailable: boolean, version?: Nullable<string>, supportedFiles?: Array<string>, installationInstructions?: Nullable<string>);
+        get linterName(): string;
+        get isAvailable(): boolean;
+        get version(): Nullable<string>;
+        get supportedFiles(): Array<string>;
+        get installationInstructions(): Nullable<string>;
+        copy(linterName?: string, isAvailable?: boolean, version?: Nullable<string>, supportedFiles?: Array<string>, installationInstructions?: Nullable<string>): cc.unitmesh.agent.linter.JsLinterDetectionResult;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsLinterDetectionResult.$metadata$ {
+        const constructor: abstract new () => JsLinterDetectionResult;
+    }
+    class JsLinterConfig {
+        constructor(name: string, technology: string, category: string, fileExtensions: Array<string>, versionCommand: string, description: string);
+        get name(): string;
+        get technology(): string;
+        get category(): string;
+        get fileExtensions(): Array<string>;
+        get versionCommand(): string;
+        get description(): string;
+        copy(name?: string, technology?: string, category?: string, fileExtensions?: Array<string>, versionCommand?: string, description?: string): cc.unitmesh.agent.linter.JsLinterConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsLinterConfig.$metadata$ {
+        const constructor: abstract new () => JsLinterConfig;
+    }
+    class JsFileLintSummary {
+        constructor(filePath: string, linterName: string, totalIssues: number, errorCount: number, warningCount: number, infoCount: number, topIssues: Array<cc.unitmesh.agent.linter.JsLintIssue>, hasMoreIssues: boolean);
+        get filePath(): string;
+        get linterName(): string;
+        get totalIssues(): number;
+        get errorCount(): number;
+        get warningCount(): number;
+        get infoCount(): number;
+        get topIssues(): Array<cc.unitmesh.agent.linter.JsLintIssue>;
+        get hasMoreIssues(): boolean;
+        copy(filePath?: string, linterName?: string, totalIssues?: number, errorCount?: number, warningCount?: number, infoCount?: number, topIssues?: Array<cc.unitmesh.agent.linter.JsLintIssue>, hasMoreIssues?: boolean): cc.unitmesh.agent.linter.JsFileLintSummary;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsFileLintSummary.$metadata$ {
+        const constructor: abstract new () => JsFileLintSummary;
+    }
+    class JsLinterSummary {
+        constructor(totalFiles: number, filesWithIssues: number, totalIssues: number, errorCount: number, warningCount: number, infoCount: number, fileIssues: Array<cc.unitmesh.agent.linter.JsFileLintSummary>, executedLinters: Array<string>);
+        get totalFiles(): number;
+        get filesWithIssues(): number;
+        get totalIssues(): number;
+        get errorCount(): number;
+        get warningCount(): number;
+        get infoCount(): number;
+        get fileIssues(): Array<cc.unitmesh.agent.linter.JsFileLintSummary>;
+        get executedLinters(): Array<string>;
+        copy(totalFiles?: number, filesWithIssues?: number, totalIssues?: number, errorCount?: number, warningCount?: number, infoCount?: number, fileIssues?: Array<cc.unitmesh.agent.linter.JsFileLintSummary>, executedLinters?: Array<string>): cc.unitmesh.agent.linter.JsLinterSummary;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsLinterSummary.$metadata$ {
+        const constructor: abstract new () => JsLinterSummary;
+    }
+    namespace JsLinterSummary {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                format(linterSummary: cc.unitmesh.agent.linter.JsLinterSummary): string;
+                private constructor();
+            }
+        }
+    }
+    class JsLintIssue {
+        constructor(line: number, column: number, severity: string, message: string, rule?: Nullable<string>, suggestion?: Nullable<string>, filePath?: Nullable<string>);
+        get line(): number;
+        get column(): number;
+        get severity(): string;
+        get message(): string;
+        get rule(): Nullable<string>;
+        get suggestion(): Nullable<string>;
+        get filePath(): Nullable<string>;
+        copy(line?: number, column?: number, severity?: string, message?: string, rule?: Nullable<string>, suggestion?: Nullable<string>, filePath?: Nullable<string>): cc.unitmesh.agent.linter.JsLintIssue;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsLintIssue.$metadata$ {
+        const constructor: abstract new () => JsLintIssue;
+    }
+    class JsLintResult {
+        constructor(filePath: string, issues: Array<cc.unitmesh.agent.linter.JsLintIssue>, success: boolean, errorMessage: Nullable<string> | undefined, linterName: string);
+        get filePath(): string;
+        get issues(): Array<cc.unitmesh.agent.linter.JsLintIssue>;
+        get success(): boolean;
+        get errorMessage(): Nullable<string>;
+        get linterName(): string;
+        get hasIssues(): boolean;
+        get errorCount(): number;
+        get warningCount(): number;
+        copy(filePath?: string, issues?: Array<cc.unitmesh.agent.linter.JsLintIssue>, success?: boolean, errorMessage?: Nullable<string>, linterName?: string): cc.unitmesh.agent.linter.JsLintResult;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsLintResult.$metadata$ {
+        const constructor: abstract new () => JsLintResult;
+    }
+    class JsAILinterFactory {
+        constructor(projectPath: string, llmService: any/* cc.unitmesh.llm.KoogLLMService */);
+        createLinter(linterName: string): Nullable<cc.unitmesh.agent.linter.JsAILinter>;
+        createAvailableLinters(): Promise<Array<cc.unitmesh.agent.linter.JsAILinter>>;
+        createLintersForFiles(filePaths: Array<string>): Promise<Array<cc.unitmesh.agent.linter.JsAILinter>>;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsAILinterFactory.$metadata$ {
+        const constructor: abstract new () => JsAILinterFactory;
+    }
+    class JsAILinter {
+        constructor(linter: any/* cc.unitmesh.agent.linter.AILinter */);
+        get name(): string;
+        get description(): string;
+        get supportedExtensions(): Array<string>;
+        isAvailable(): Promise<boolean>;
+        lintFile(filePath: string, projectPath: string): Promise<cc.unitmesh.agent.linter.JsLintResult>;
+        lintFiles(filePaths: Array<string>, projectPath: string): Promise<Array<cc.unitmesh.agent.linter.JsLintResult>>;
+        getInstallationInstructions(): string;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsAILinter.$metadata$ {
+        const constructor: abstract new () => JsAILinter;
+    }
+}
+export declare namespace cc.unitmesh.agent.subagent {
+    class JsErrorContext {
+        constructor(command: string, errorMessage: string, exitCode?: Nullable<number>, stdout?: Nullable<string>, stderr?: Nullable<string>);
+        get command(): string;
+        get errorMessage(): string;
+        get exitCode(): Nullable<number>;
+        get stdout(): Nullable<string>;
+        get stderr(): Nullable<string>;
+        toCommon(): any/* cc.unitmesh.agent.subagent.ErrorContext */;
+        copy(command?: string, errorMessage?: string, exitCode?: Nullable<number>, stdout?: Nullable<string>, stderr?: Nullable<string>): cc.unitmesh.agent.subagent.JsErrorContext;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsErrorContext.$metadata$ {
+        const constructor: abstract new () => JsErrorContext;
+    }
+    class JsAnalysisContext {
+        constructor(content: string, contentType?: string, source?: string, metadata?: kotlin.collections.KtMap<string, string>);
+        get content(): string;
+        get contentType(): string;
+        get source(): string;
+        get metadata(): kotlin.collections.KtMap<string, string>;
+        toCommon(): any/* cc.unitmesh.agent.subagent.ContentHandlerContext */;
+        copy(content?: string, contentType?: string, source?: string, metadata?: kotlin.collections.KtMap<string, string>): cc.unitmesh.agent.subagent.JsAnalysisContext;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsAnalysisContext.$metadata$ {
+        const constructor: abstract new () => JsAnalysisContext;
+    }
+    class JsErrorRecoveryAgent {
+        constructor(projectPath: string, llmService: any/* cc.unitmesh.llm.KoogLLMService */);
+        execute(errorContext: cc.unitmesh.agent.subagent.JsErrorContext): Promise<any/* cc.unitmesh.agent.tool.ToolResult.AgentResult */>;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsErrorRecoveryAgent.$metadata$ {
+        const constructor: abstract new () => JsErrorRecoveryAgent;
+    }
+    class JsAnalysisAgent {
+        constructor(llmService: any/* cc.unitmesh.llm.KoogLLMService */, contentThreshold?: number);
+        execute(context: cc.unitmesh.agent.subagent.JsAnalysisContext): Promise<any/* cc.unitmesh.agent.tool.ToolResult.AgentResult */>;
+        needsHandling(content: string): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsAnalysisAgent.$metadata$ {
+        const constructor: abstract new () => JsAnalysisAgent;
+    }
+    class JsNanoDSLContext {
+        constructor(description: string);
+        get description(): string;
+        toCommon(): any/* cc.unitmesh.agent.subagent.NanoDSLContext */;
+        copy(description?: string): cc.unitmesh.agent.subagent.JsNanoDSLContext;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsNanoDSLContext.$metadata$ {
+        const constructor: abstract new () => JsNanoDSLContext;
+    }
+    class JsNanoDSLAgent {
+        constructor(llmService: any/* cc.unitmesh.llm.KoogLLMService */, promptTemplate?: Nullable<string>);
+        execute(context: cc.unitmesh.agent.subagent.JsNanoDSLContext): Promise<any/* cc.unitmesh.agent.tool.ToolResult.AgentResult */>;
+        generate(description: string): Promise<any/* cc.unitmesh.agent.tool.ToolResult.AgentResult */>;
+        shouldTrigger(content: string): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsNanoDSLAgent.$metadata$ {
+        const constructor: abstract new () => JsNanoDSLAgent;
+    }
+    class JsChartContext {
+        constructor(description: string);
+        get description(): string;
+        toCommon(): any/* cc.unitmesh.agent.subagent.ChartContext */;
+        copy(description?: string): cc.unitmesh.agent.subagent.JsChartContext;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsChartContext.$metadata$ {
+        const constructor: abstract new () => JsChartContext;
+    }
+    class JsChartAgent {
+        constructor(llmService: any/* cc.unitmesh.llm.KoogLLMService */, promptTemplate?: Nullable<string>);
+        execute(context: cc.unitmesh.agent.subagent.JsChartContext): Promise<any/* cc.unitmesh.agent.tool.ToolResult.AgentResult */>;
+        generate(description: string): Promise<any/* cc.unitmesh.agent.tool.ToolResult.AgentResult */>;
+        shouldTrigger(content: string): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsChartAgent.$metadata$ {
+        const constructor: abstract new () => JsChartAgent;
+    }
+}
+export declare namespace cc.unitmesh.agent.ui {
+    abstract class ColorSystem extends KtSingleton<ColorSystem.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace ColorSystem.$metadata$ {
+        abstract class constructor {
+            get indigoScale(): any;
+            get cyanScale(): any;
+            get neutralScale(): any;
+            get greenScale(): any;
+            get amberScale(): any;
+            get redScale(): any;
+            get blueScale(): any;
+            get lightTheme(): any/* cc.unitmesh.agent.ui.ColorTheme */;
+            get darkTheme(): any/* cc.unitmesh.agent.ui.ColorTheme */;
+            private constructor();
+        }
+    }
+}
+export declare namespace cc.unitmesh.devins.filesystem {
+    class JsFileSystemFactory {
+        constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsFileSystemFactory.$metadata$ {
+        const constructor: abstract new () => JsFileSystemFactory;
+    }
+    namespace JsFileSystemFactory {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                createFileSystem(projectPath: string): any/* cc.unitmesh.devins.filesystem.DefaultFileSystem */;
+                createEmptyFileSystem(): any/* cc.unitmesh.devins.filesystem.EmptyFileSystem */;
+                private constructor();
+            }
+        }
+    }
+    class FileSystem {
+        constructor(projectPath: string);
+        getProjectPath(): Nullable<string>;
+        readFile(path: string): Nullable<string>;
+        writeFile(path: string, content: string): boolean;
+        exists(path: string): boolean;
+        isDirectory(path: string): boolean;
+        listFiles(path: string, pattern?: Nullable<string>): Array<string>;
+        searchFiles(pattern: string, maxDepth?: number, maxResults?: number): Array<string>;
+        resolvePath(relativePath: string): string;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace FileSystem.$metadata$ {
+        const constructor: abstract new () => FileSystem;
+    }
+}
+export declare namespace cc.unitmesh.llm {
+    class JsKoogLLMService {
+        constructor(config: cc.unitmesh.llm.JsModelConfig, compressionConfig?: Nullable<cc.unitmesh.llm.JsCompressionConfig>);
+        streamPrompt(userPrompt: string, historyMessages: Array<cc.unitmesh.llm.JsMessage> | undefined, onChunk: (p0: string) => void, onError?: Nullable<(p0: Error) => void>, onComplete?: Nullable<() => void>, compileDevIns?: boolean): Promise<void>;
+        sendPrompt(prompt: string): Promise<string>;
+        getMaxTokens(): number;
+        getLastTokenInfo(): cc.unitmesh.llm.JsTokenInfo;
+        resetCompressionState(): void;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsKoogLLMService.$metadata$ {
+        const constructor: abstract new () => JsKoogLLMService;
+    }
+    namespace JsKoogLLMService {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                create(config: cc.unitmesh.llm.JsModelConfig, compressionConfig?: Nullable<cc.unitmesh.llm.JsCompressionConfig>): cc.unitmesh.llm.JsKoogLLMService;
+                private constructor();
+            }
+        }
+    }
+    class JsModelConfig {
+        constructor(providerName: string, modelName: string, apiKey?: string, temperature?: number, maxTokens?: number, baseUrl?: string);
+        get providerName(): string;
+        get modelName(): string;
+        get apiKey(): string;
+        get temperature(): number;
+        get maxTokens(): number;
+        get baseUrl(): string;
+        toKotlinConfig(): any/* cc.unitmesh.llm.ModelConfig */;
+        copy(providerName?: string, modelName?: string, apiKey?: string, temperature?: number, maxTokens?: number, baseUrl?: string): cc.unitmesh.llm.JsModelConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsModelConfig.$metadata$ {
+        const constructor: abstract new () => JsModelConfig;
+    }
+    class JsMessage {
+        constructor(role: string, content: string);
+        get role(): string;
+        get content(): string;
+        toKotlinMessage(): any/* cc.unitmesh.devins.llm.Message */;
+        copy(role?: string, content?: string): cc.unitmesh.llm.JsMessage;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsMessage.$metadata$ {
+        const constructor: abstract new () => JsMessage;
+    }
+    class JsNamedModelConfig {
+        constructor(name: string, providerName: string, modelName: string, apiKey?: string, temperature?: number, maxTokens?: number, baseUrl?: string);
+        get name(): string;
+        get providerName(): string;
+        get modelName(): string;
+        get apiKey(): string;
+        get temperature(): number;
+        get maxTokens(): number;
+        get baseUrl(): string;
+        toKotlin(): any/* cc.unitmesh.llm.NamedModelConfig */;
+        copy(name?: string, providerName?: string, modelName?: string, apiKey?: string, temperature?: number, maxTokens?: number, baseUrl?: string): cc.unitmesh.llm.JsNamedModelConfig;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsNamedModelConfig.$metadata$ {
+        const constructor: abstract new () => JsNamedModelConfig;
+    }
+    namespace JsNamedModelConfig {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                fromKotlin(config: any/* cc.unitmesh.llm.NamedModelConfig */): cc.unitmesh.llm.JsNamedModelConfig;
+                private constructor();
+            }
+        }
+    }
+    class JsResult {
+        constructor(success: boolean, value: string, error: Nullable<string>);
+        get success(): boolean;
+        get value(): string;
+        get error(): Nullable<string>;
+        copy(success?: boolean, value?: string, error?: Nullable<string>): cc.unitmesh.llm.JsResult;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsResult.$metadata$ {
+        const constructor: abstract new () => JsResult;
+    }
+    abstract class JsModelRegistry extends KtSingleton<JsModelRegistry.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsModelRegistry.$metadata$ {
+        abstract class constructor {
+            getAvailableModels(providerName: string): Array<string>;
+            getAllProviders(): Array<string>;
+            private constructor();
+        }
+    }
+    class JsCompletionManager {
+        constructor();
+        initWorkspace(workspacePath: string): Promise<boolean>;
+        getCompletions(text: string, cursorPosition: number): Array<cc.unitmesh.llm.JsCompletionItem>;
+        applyCompletion(text: string, cursorPosition: number, completionIndex: number): Nullable<cc.unitmesh.llm.JsInsertResult>;
+        shouldTrigger(char: string): boolean;
+        getSupportedTriggers(): Array<string>;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsCompletionManager.$metadata$ {
+        const constructor: abstract new () => JsCompletionManager;
+    }
+    class JsCompletionItem {
+        constructor(text: string, displayText: string, description: Nullable<string>, icon: Nullable<string>, triggerType: string, index: number);
+        get text(): string;
+        get displayText(): string;
+        get description(): Nullable<string>;
+        get icon(): Nullable<string>;
+        get triggerType(): string;
+        get index(): number;
+        copy(text?: string, displayText?: string, description?: Nullable<string>, icon?: Nullable<string>, triggerType?: string, index?: number): cc.unitmesh.llm.JsCompletionItem;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsCompletionItem.$metadata$ {
+        const constructor: abstract new () => JsCompletionItem;
+    }
+    class JsInsertResult {
+        constructor(newText: string, newCursorPosition: number, shouldTriggerNextCompletion: boolean);
+        get newText(): string;
+        get newCursorPosition(): number;
+        get shouldTriggerNextCompletion(): boolean;
+        copy(newText?: string, newCursorPosition?: number, shouldTriggerNextCompletion?: boolean): cc.unitmesh.llm.JsInsertResult;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsInsertResult.$metadata$ {
+        const constructor: abstract new () => JsInsertResult;
+    }
+    class JsDevInsCompiler {
+        constructor();
+        compile(source: string, variables?: any): Promise<cc.unitmesh.llm.JsDevInsResult>;
+        compileToString(source: string): Promise<string>;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDevInsCompiler.$metadata$ {
+        const constructor: abstract new () => JsDevInsCompiler;
+    }
+    class JsDevInsResult {
+        constructor(success: boolean, output: string, errorMessage: Nullable<string>, hasCommand: boolean);
+        get success(): boolean;
+        get output(): string;
+        get errorMessage(): Nullable<string>;
+        get hasCommand(): boolean;
+        copy(success?: boolean, output?: string, errorMessage?: Nullable<string>, hasCommand?: boolean): cc.unitmesh.llm.JsDevInsResult;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDevInsResult.$metadata$ {
+        const constructor: abstract new () => JsDevInsResult;
+    }
+    class JsToolRegistry {
+        constructor(projectPath: string);
+        readFile(path: string, startLine?: Nullable<number>, endLine?: Nullable<number>): Promise<cc.unitmesh.llm.JsToolResult>;
+        writeFile(path: string, content: string, createDirectories?: boolean): Promise<cc.unitmesh.llm.JsToolResult>;
+        glob(pattern: string, path?: string, includeFileInfo?: boolean): Promise<cc.unitmesh.llm.JsToolResult>;
+        grep(pattern: string, path?: string, include?: Nullable<string>, exclude?: Nullable<string>, recursive?: boolean, caseSensitive?: boolean): Promise<cc.unitmesh.llm.JsToolResult>;
+        shell(command: string, workingDirectory?: Nullable<string>, timeoutMs?: number): Promise<cc.unitmesh.llm.JsToolResult>;
+        getAvailableTools(): Array<string>;
+        getAgentTools(): Array<cc.unitmesh.llm.JsAgentTool>;
+        formatToolListForAI(): string;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsToolRegistry.$metadata$ {
+        const constructor: abstract new () => JsToolRegistry;
+    }
+    class JsToolResult {
+        constructor(success: boolean, output: string, errorMessage: Nullable<string>, metadata: kotlin.collections.KtMap<string, string>);
+        get success(): boolean;
+        get output(): string;
+        get errorMessage(): Nullable<string>;
+        get metadata(): kotlin.collections.KtMap<string, string>;
+        copy(success?: boolean, output?: string, errorMessage?: Nullable<string>, metadata?: kotlin.collections.KtMap<string, string>): cc.unitmesh.llm.JsToolResult;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsToolResult.$metadata$ {
+        const constructor: abstract new () => JsToolResult;
+    }
+    class JsAgentTool {
+        constructor(name: string, description: string, example: string);
+        get name(): string;
+        get description(): string;
+        get example(): string;
+        copy(name?: string, description?: string, example?: string): cc.unitmesh.llm.JsAgentTool;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsAgentTool.$metadata$ {
+        const constructor: abstract new () => JsAgentTool;
+    }
+    abstract class JsDocumentParserFactory extends KtSingleton<JsDocumentParserFactory.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDocumentParserFactory.$metadata$ {
+        abstract class constructor {
+            createParserForFile(filePath: string): Nullable<any>/* Nullable<cc.unitmesh.devins.document.DocumentParserService> */;
+            private constructor();
+        }
+    }
+    abstract class JsDocumentRegistry extends KtSingleton<JsDocumentRegistry.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDocumentRegistry.$metadata$ {
+        abstract class constructor {
+            initializePlatformParsers(): void;
+            getParserForFile(filePath: string): Nullable<any>/* Nullable<cc.unitmesh.devins.document.DocumentParserService> */;
+            private constructor();
+        }
+    }
+    class JsCompressionConfig {
+        constructor(contextPercentageThreshold?: number, preserveRecentRatio?: number, autoCompressionEnabled?: boolean, retryAfterMessages?: number);
+        get contextPercentageThreshold(): number;
+        get preserveRecentRatio(): number;
+        get autoCompressionEnabled(): boolean;
+        get retryAfterMessages(): number;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsCompressionConfig.$metadata$ {
+        const constructor: abstract new () => JsCompressionConfig;
+    }
+    class JsTokenInfo {
+        constructor(totalTokens?: number, inputTokens?: number, outputTokens?: number, timestamp?: number);
+        get totalTokens(): number;
+        get inputTokens(): number;
+        get outputTokens(): number;
+        get timestamp(): number;
+        getUsagePercentage(maxTokens: number): number;
+        needsCompression(maxTokens: number, threshold: number): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsTokenInfo.$metadata$ {
+        const constructor: abstract new () => JsTokenInfo;
+    }
+    namespace JsTokenInfo {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+    class JsChatCompressionInfo {
+        constructor(originalTokenCount: number, newTokenCount: number, compressionStatus: string, errorMessage?: Nullable<string>);
+        get originalTokenCount(): number;
+        get newTokenCount(): number;
+        get compressionStatus(): string;
+        get errorMessage(): Nullable<string>;
+        getCompressionRatio(): number;
+        getTokensSaved(): number;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsChatCompressionInfo.$metadata$ {
+        const constructor: abstract new () => JsChatCompressionInfo;
+    }
+    namespace JsChatCompressionInfo {
+        abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+            private constructor();
+        }
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace Companion.$metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+    class JsDomainDictGenerator {
+        constructor(projectPath: string, modelConfig: cc.unitmesh.llm.JsModelConfig, maxTokenLength?: number);
+        generate(): Promise<string>;
+        generateAndSave(): Promise<cc.unitmesh.llm.JsDomainDictResult>;
+        exists(): Promise<boolean>;
+        loadContent(): Promise<Nullable<string>>;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDomainDictGenerator.$metadata$ {
+        const constructor: abstract new () => JsDomainDictGenerator;
+    }
+    class JsDomainDictResult {
+        constructor(success: boolean, content: string, errorMessage: Nullable<string>);
+        get success(): boolean;
+        get content(): string;
+        get errorMessage(): Nullable<string>;
+        copy(success?: boolean, content?: string, errorMessage?: Nullable<string>): cc.unitmesh.llm.JsDomainDictResult;
+        toString(): string;
+        hashCode(): number;
+        equals(other: Nullable<any>): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDomainDictResult.$metadata$ {
+        const constructor: abstract new () => JsDomainDictResult;
+    }
+    class JsDomainDictService {
+        constructor(fileSystem: any/* cc.unitmesh.devins.filesystem.DefaultFileSystem */);
+        loadContent(): Promise<Nullable<string>>;
+        exists(): boolean;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsDomainDictService.$metadata$ {
+        const constructor: abstract new () => JsDomainDictService;
+    }
+    class JsPromptEnhancer {
+        constructor(llmService: any/* cc.unitmesh.llm.KoogLLMService */, fileSystem: any/* cc.unitmesh.devins.filesystem.DefaultFileSystem */, jsDomainDictService: cc.unitmesh.llm.JsDomainDictService);
+        enhance(userInput: string, language: string): Promise<string>;
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace JsPromptEnhancer.$metadata$ {
+        const constructor: abstract new () => JsPromptEnhancer;
+    }
+    function createPromptEnhancer(llmService: any/* cc.unitmesh.llm.KoogLLMService */, fileSystem: any/* cc.unitmesh.devins.filesystem.DefaultFileSystem */, jsDomainDictService: cc.unitmesh.llm.JsDomainDictService): cc.unitmesh.llm.JsPromptEnhancer;
+}
+export as namespace cc_unitmesh_mpp_core;