@co0ontty/wand 4.85.1 → 4.87.0-beta.gd2f0f8f

package/dist/daemon-maintenance.js

@@ -0,0 +1,164 @@
+/** One admission barrier for PTY and structured starts, not for ongoing input/output. */
+export class DaemonAdmission {
+    barrier = null;
+    active = 0;
+    settled = null;
+    async run(operation) {
+        while (this.barrier)
+            await this.barrier;
+        this.active++;
+        try {
+            return await operation();
+        }
+        finally {
+            if (--this.active === 0)
+                this.settled?.();
+        }
+    }
+    async exclusive(operation) {
+        while (this.barrier)
+            await this.barrier;
+        let release;
+        this.barrier = new Promise((resolve) => { release = resolve; });
+        try {
+            if (this.active)
+                await new Promise((resolve) => { this.settled = resolve; });
+            return await operation();
+        }
+        finally {
+            this.settled = null;
+            this.barrier = null;
+            release();
+        }
+    }
+    terminal(host) {
+        return {
+            persistent: host.persistent,
+            attach: (id, seq) => host.attach(id, seq),
+            createOrAttach: (request, seq) => this.run(() => host.createOrAttach(request, seq)),
+            forget: (id) => host.forget(id),
+            flush: () => host.flush?.(),
+            disconnect: () => host.disconnect(),
+        };
+    }
+    structured(host) {
+        return {
+            persistent: host.persistent,
+            spawnStructured: (request) => this.run(() => host.spawnStructured(request)),
+            listRuns: () => host.listRuns(),
+            attachRun: (id) => host.attachRun(id),
+            adoptRun: (id) => host.adoptRun(id),
+            forgetRun: (id) => host.forgetRun(id),
+        };
+    }
+}
+/** Lifecycle-owned worker. GET only projects its state; it never performs maintenance. */
+export class DaemonMaintenance {
+    options;
+    state = { pending: false, phase: "idle" };
+    timer = null;
+    flight = null;
+    stopped = false;
+    idleSince = null;
+    failures = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    status() { return { ...this.state }; }
+    start() {
+        if (this.timer || this.flight || this.stopped || !this.options.targets.length)
+            return;
+        const poll = async () => {
+            await this.check();
+            if (this.stopped)
+                return;
+            this.timer = setTimeout(() => { this.timer = null; void poll(); }, Math.min(300_000, 15_000 * 2 ** Math.min(this.failures, 5)));
+            this.timer.unref();
+        };
+        void poll();
+    }
+    check() {
+        if (this.stopped)
+            return Promise.resolve();
+        if (this.flight)
+            return this.flight;
+        this.flight = this.inspectAndUpdate().catch((error) => {
+            this.idleSince = null;
+            if (this.state.pending)
+                this.state = { pending: true, phase: "retrying" };
+            this.failures++;
+            // Backoff plus rate-limited diagnostics, not a repeated user notification.
+            if (this.failures === 1 || this.failures % 10 === 0)
+                this.options.log(error);
+        }).finally(() => { this.flight = null; });
+        return this.flight;
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        await this.flight;
+    }
+    async inspectAndUpdate() {
+        const o = this.options;
+        if (!o.available()) {
+            this.idleSince = null;
+            return;
+        }
+        // Reading full replay inventories while a known session is busy only adds
+        // load. Versions still refresh so the waiting notice remains accurate.
+        const includeInventory = !o.busy();
+        const inspected = await Promise.allSettled(o.targets.map((target) => target.inspect(includeInventory)));
+        if (inspected.some((result) => result.status === "fulfilled" && result.value.pending)) {
+            this.state = { pending: true, phase: "waiting" };
+        }
+        const snapshots = inspected.map((result) => {
+            if (result.status === "rejected")
+                throw result.reason;
+            return result.value;
+        });
+        const pending = snapshots.some((snapshot) => snapshot.pending);
+        this.state = { pending, phase: pending ? "waiting" : "idle" };
+        if (!pending)
+            this.failures = 0;
+        if (!pending || o.busy() || snapshots.some((snapshot) => snapshot.running !== 0)) {
+            this.idleSince = null;
+            return;
+        }
+        const now = (o.now ?? Date.now)();
+        this.idleSince ??= now;
+        if (now - this.idleSince < (o.quietMs ?? 10_000))
+            return;
+        await o.admission.exclusive(async () => {
+            if (this.stopped || !o.available())
+                return;
+            const releaseCore = o.beginCoreDrain();
+            try {
+                // Close the check/start race, including unowned daemon runs and shells
+                // that are idle in the UI but still have a live PTY process.
+                const fresh = await Promise.all(o.targets.map((target) => target.inspect()));
+                if (this.stopped || !o.available() || o.busy() || fresh.some((snapshot) => snapshot.running !== 0))
+                    return;
+                this.state = { pending: true, phase: "updating" };
+                for (let i = 0; i < fresh.length; i++) {
+                    if (this.stopped || !o.available() || o.busy())
+                        return;
+                    if (fresh[i].pending)
+                        await o.targets[i].restart(fresh[i]);
+                }
+                const after = await Promise.all(o.targets.map((target) => target.inspect()));
+                if (after.some((snapshot) => snapshot.pending))
+                    throw new Error("Daemon replacement is not ready yet");
+                this.state = { pending: false, phase: "idle" };
+                this.failures = 0;
+            }
+            finally {
+                this.idleSince = null;
+                releaseCore();
+                if (this.state.phase === "updating")
+                    this.state = { pending: true, phase: "waiting" };
+            }
+        });
+    }
+}

package/dist/decision-expert-employee.d.ts

@@ -0,0 +1,6 @@
+import type { SiliconEmployee } from "./ai-team-types.js";
+import type { WandTaskAgent } from "./task-types.js";
+export declare const DECISION_EXPERT_DUTY = "Wand \u51B3\u7B56\u4E13\u5BB6\uFF1A\u6839\u636E\u6700\u5C11\u5FC5\u8981\u8BC1\u636E\u505A\u6709\u754C\u9009\u62E9\u3001\u8BC4\u5206\u4E0E\u662F\u975E\u5224\u65AD\uFF1B\u5148\u6838\u5BF9\u672C\u673A\u80FD\u529B\uFF0C\u4F18\u5148\u672C\u5730\u51B3\u7B56\uFF0C\u5907\u7528\u514D\u8D39\u6A21\u578B\u3002";
+export declare const DECISION_EXPERT_PROMPT: string;
+export declare function decisionExpertSeedAgents(): WandTaskAgent[];
+export declare function decisionExpertDefinition(now: string, existing?: SiliconEmployee | null): SiliconEmployee;

package/dist/decision-expert-employee.js

@@ -0,0 +1,22 @@
+import { SYSTEM_EMPLOYEE_TAG } from "./ai-team-types.js";
+import { DECISION_EXPERT_ID, DECISION_EXPERT_KEY, DECISION_EXPERT_NAME, WAND_LOCAL_DECISION_MODEL } from "./decision-expert-identity.js";
+import { OPENROUTER_FREE_SELECTOR } from "./openrouter-free-selection.js";
+export const DECISION_EXPERT_DUTY = "Wand 决策专家：根据最少必要证据做有界选择、评分与是非判断；先核对本机能力，优先本地决策，备用免费模型。";
+export const DECISION_EXPERT_PROMPT = [
+    "你是 Wand 内置系统员工「决策专家」。你的职责是基于用户提供的证据，做有界候选选择、评分与是非判断。",
+    "首选为 Wand 的 LAYA 本地决策模型，备用默认 Wand 免费分组。LAYA 不生成开放式文本，不伪装成聊天模型。",
+    "先核对机器的 CPU、内存、Apple Silicon / Metal 和运行时健康。性能/平台不足时明确说明原因，建议配置你的调用链，不能捏造可以运行。",
+    "只使用输入中已授权的最少证据，不读取别人的知识/私聊。概率不是正确性保证，更不是权限、删除、发布或付款批准。",
+    "严格输出任务要求的格式；不编造选项、解释、执行结果或事实。失败有明确原因，不盲目重复已执行/未知送达的工作。",
+    "免费分组在每次请求前重新核对价格；没有免费候选时停止并提示配置，不静默换付费模型。",
+].join("\n");
+export function decisionExpertSeedAgents() {
+    return [WAND_LOCAL_DECISION_MODEL, OPENROUTER_FREE_SELECTOR].map(model => ({ provider: "pi", engine: "sdk", model,
+        thinkingEffort: "off", mode: "default", kind: "structured" }));
+}
+export function decisionExpertDefinition(now, existing) {
+    return { id: existing?.id ?? DECISION_EXPERT_ID, systemKey: DECISION_EXPERT_KEY, name: DECISION_EXPERT_NAME,
+        duty: DECISION_EXPERT_DUTY, prompt: DECISION_EXPERT_PROMPT, avatar: "", tags: [SYSTEM_EMPLOYEE_TAG],
+        agents: existing?.agents.length ? existing.agents : decisionExpertSeedAgents(),
+        createdAt: existing?.createdAt ?? now, updatedAt: now };
+}

package/dist/decision-expert-identity.d.ts

@@ -0,0 +1,7 @@
+/** Pure identity shared by server and clients; LAYA is a bounded decision source, never a chat model. */
+export declare const DECISION_EXPERT_KEY = "wand-decision-expert";
+export declare const DECISION_EXPERT_ID = "e_wand_decision_expert";
+export declare const DECISION_EXPERT_NAME = "\u51B3\u7B56\u4E13\u5BB6";
+export declare const WAND_LOCAL_DECISION_MODEL = "wand-decision/laya";
+export declare const WAND_LOCAL_DECISION_LABEL = "Wand \u672C\u5730\u51B3\u7B56\u6A21\u578B \u00B7 LAYA";
+export declare function isLocalDecisionModel(value: string | null | undefined): boolean;

package/dist/decision-expert-identity.js

@@ -0,0 +1,7 @@
+/** Pure identity shared by server and clients; LAYA is a bounded decision source, never a chat model. */
+export const DECISION_EXPERT_KEY = "wand-decision-expert";
+export const DECISION_EXPERT_ID = "e_wand_decision_expert";
+export const DECISION_EXPERT_NAME = "决策专家";
+export const WAND_LOCAL_DECISION_MODEL = "wand-decision/laya";
+export const WAND_LOCAL_DECISION_LABEL = "Wand 本地决策模型 · LAYA";
+export function isLocalDecisionModel(value) { return value === WAND_LOCAL_DECISION_MODEL; }

package/dist/decision-hardware.d.ts

@@ -0,0 +1,19 @@
+export interface DecisionHardwareSnapshot {
+    platform: string;
+    arch: string;
+    memoryBytes: number;
+    availableBytes: number;
+    cpuCount: number;
+    metal?: boolean;
+}
+export interface DecisionHardwareAssessment {
+    suitable: boolean;
+    code: "ready" | "platform" | "metal" | "memory" | "cpu";
+    message: string;
+    memoryGiB: number;
+    availableGiB: number;
+    cpuCount: number;
+    minimumMemoryGiB: number;
+}
+export declare function assessDecisionHardware(value: DecisionHardwareSnapshot): DecisionHardwareAssessment;
+export declare function decisionHardware(): DecisionHardwareAssessment;

package/dist/decision-hardware.js

@@ -0,0 +1,19 @@
+import os from "node:os";
+export function assessDecisionHardware(value) {
+    const gib = 1024 ** 3, memoryGiB = Math.round(value.memoryBytes / gib * 10) / 10, availableGiB = Math.round(value.availableBytes / gib * 10) / 10;
+    const base = { memoryGiB, availableGiB, cpuCount: value.cpuCount, minimumMemoryGiB: 8 };
+    const insufficient = "当前机器性能或平台条件不足，建议配置「决策专家」员工的调用链，通过备用模型使用。";
+    if (value.platform !== "darwin" || value.arch !== "arm64")
+        return { ...base, suitable: false, code: "platform", message: `LAYA 本地决策需要 Apple Silicon macOS / Metal。${insufficient}` };
+    if (value.metal === false)
+        return { ...base, suitable: false, code: "metal", message: `当前 Metal 不可用。${insufficient}` };
+    if (value.memoryBytes < 7.5 * gib)
+        return { ...base, suitable: false, code: "memory", message: `当前机器性能不够（内存 ${memoryGiB} GiB，建议至少 8 GiB）。请配置「决策专家」员工调用链使用备用模型。` };
+    if (value.cpuCount < 4)
+        return { ...base, suitable: false, code: "cpu", message: `当前机器性能不够（可用 CPU ${value.cpuCount} 核，建议至少 4 核）。请配置「决策专家」员工调用链。` };
+    // Darwin's free memory excludes reclaimable cache. Don't falsely reject an otherwise capable Mac based on that number alone.
+    return { ...base, suitable: true, code: "ready", message: "本机基本配置满足 LAYA 本地决策要求；实际运行时与 Metal 能力仍需初始化验证。" };
+}
+export function decisionHardware() {
+    return assessDecisionHardware({ platform: process.platform, arch: process.arch, memoryBytes: os.totalmem(), availableBytes: os.freemem(), cpuCount: os.availableParallelism() });
+}

package/dist/decision-service.d.ts

@@ -7,7 +7,7 @@ interface DecisionServiceOptions {
 }
 /** One bounded worker per server. It owns no sessions, permissions, tasks, or model downloads. */
 export declare class DecisionService {
-    private readonly config;
+    private config;
     private readonly options;
     private child;
     private stopping;
@@ -22,6 +22,7 @@ export declare class DecisionService {
     private readonly rates;
     private completed;
     private failed;
+    private readonly initializations;
     constructor(config: LocalDecisionConfig | undefined, options?: DecisionServiceOptions);
     status(): {
         enabled: boolean;
@@ -33,6 +34,10 @@ export declare class DecisionService {
         failed: number;
         experimental: true;
     };
+    assertConfigurable(): void;
+    configure(config: LocalDecisionConfig): void;
+    /** Explicit admin warm-up; it does not evaluate a user's task or implicitly enable the model. */
+    initialize(signal?: AbortSignal): Promise<void>;
     evaluate(value: unknown, caller: string, signal?: AbortSignal): Promise<DecisionResult>;
     dispose(): void;
     private finish;

package/dist/decision-service.js

@@ -21,6 +21,7 @@ export class DecisionService {
     rates = new Map();
     completed = 0;
     failed = 0;
+    initializations = new Set();
     constructor(config, options = {}) {
         this.config = config;
         this.options = options;
@@ -33,6 +34,60 @@ export class DecisionService {
             state: this.disposed ? "closed" : this.stopping ? "stopping" : this.child ? this.ready ? "ready" : "loading" : "stopped",
             queued: this.queue.length + Number(!!this.active), completed: this.completed, failed: this.failed, experimental: true };
     }
+    assertConfigurable() {
+        if (this.active || this.queue.length || this.initializations.size || (this.child && !this.ready)) {
+            throw new DecisionError("BUSY", "本地决策正在执行或初始化，请等待后重试。", 409);
+        }
+        if (this.disposed)
+            throw new DecisionError("UNAVAILABLE", "决策服务已关闭。", 503);
+    }
+    configure(config) {
+        this.assertConfigurable();
+        const changedRuntime = config.pythonPath !== this.config?.pythonPath || config.modelPath !== this.config?.modelPath;
+        if (changedRuntime || !config.enabled)
+            this.stopWorker();
+        this.config = { ...config };
+        this.cooldownUntil = 0;
+    }
+    /** Explicit admin warm-up; it does not evaluate a user's task or implicitly enable the model. */
+    initialize(signal) {
+        const status = this.status();
+        if (this.disposed || !status.supported || !status.configured)
+            throw new DecisionError("UNAVAILABLE", "LAYA 平台不支持或运行环境/模型尚未安装。", 503);
+        if (signal?.aborted)
+            throw new DecisionError("CANCELLED", "初始化已取消。", 499);
+        if (this.ready)
+            return Promise.resolve();
+        this.clearIdle();
+        return new Promise((resolve, reject) => {
+            const finish = (error) => {
+                if (!this.initializations.delete(waiter))
+                    return;
+                waiter.clear();
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+                if (!this.initializations.size && !this.active && !this.queue.length) {
+                    if (error)
+                        this.stopWorker();
+                    else
+                        this.pump();
+                }
+            };
+            const abort = () => finish(new DecisionError("CANCELLED", "初始化已取消。", 499));
+            const timer = setTimeout(() => finish(new DecisionError("TIMEOUT", "LAYA 初始化超时，请检查运行环境和模型。", 504)), this.options.timeoutMs ?? 45_000);
+            const waiter = { resolve: () => finish(), reject: (error) => finish(error),
+                clear: () => { clearTimeout(timer); signal?.removeEventListener("abort", abort); } };
+            this.initializations.add(waiter);
+            signal?.addEventListener("abort", abort, { once: true });
+            if (signal?.aborted) {
+                abort();
+                return;
+            }
+            this.pump();
+        });
+    }
     evaluate(value, caller, signal) {
         const request = parseDecisionRequest(value);
         const status = this.status();
@@ -128,6 +183,8 @@ export class DecisionService {
         }
     }
     failWorker(error) {
+        for (const waiter of [...this.initializations])
+            waiter.reject(error);
         const jobs = [...(this.active ? [this.active] : []), ...this.queue];
         this.active = null;
         this.queue = [];
@@ -139,7 +196,7 @@ export class DecisionService {
     pump() {
         if (this.disposed || this.active || this.stopping)
             return;
-        if (!this.queue.length) {
+        if (!this.queue.length && !this.initializations.size) {
             if (this.child && !this.idleTimer) {
                 this.idleTimer = setTimeout(() => this.stopWorker(), this.options.idleMs ?? 5 * 60_000);
                 this.idleTimer.unref();
@@ -200,6 +257,8 @@ export class DecisionService {
             if (message.type !== "ready" || message.protocol !== 1)
                 throw new Error("Unexpected ready");
             this.ready = true;
+            for (const waiter of [...this.initializations])
+                waiter.resolve();
             this.pump();
             return;
         }

package/dist/decision-types.d.ts

@@ -7,6 +7,7 @@ export interface LocalDecisionConfig {
     pythonPath: string;
     modelPath: string;
 }
+export declare function parseLocalDecisionConfig(value: unknown): LocalDecisionConfig;
 export interface DecisionQuestion {
     type: "choice" | "score" | "noul";
     instructions: string;

package/dist/decision-types.js

@@ -1,7 +1,19 @@
+import { isAbsolute } from "node:path";
 export const DECISION_MAX_BYTES = 32 * 1024;
 export const DECISION_MAX_QUESTIONS = 8;
 export const DECISION_MAX_OPTIONS = 8;
 export const DECISION_CHECKPOINT = "aac6fef/laya-multilingual-mlx";
+export function parseLocalDecisionConfig(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("本地决策配置无效。");
+    const input = value;
+    if (Object.keys(input).some((key) => !["enabled", "pythonPath", "modelPath"].includes(key))
+        || typeof input.enabled !== "boolean" || typeof input.pythonPath !== "string" || typeof input.modelPath !== "string"
+        || (input.pythonPath !== "" && !isAbsolute(input.pythonPath)) || (input.modelPath !== "" && !isAbsolute(input.modelPath))) {
+        throw new Error("本地决策需有效的启用状态及受信任的绝对路径。");
+    }
+    return { enabled: input.enabled, pythonPath: input.pythonPath, modelPath: input.modelPath };
+}
 export class DecisionError extends Error {
     code;
     status;

package/dist/git-quick-commit.js

@@ -780,7 +780,7 @@ async function callCliCandidates(request, cwd, language, opts, parseOutput) {
         .flatMap((candidate) => resolveModelGroupModels(opts.modelGroups, candidate.provider, candidate.model, { preferDefault: !candidate.model || candidate.model === "default" })
         .map((model) => ({ ...candidate, model: model || undefined })));
     if (opts.employeeChannelOnly && !opts.cliCandidates?.length) {
-        throw new QuickCommitError("系统员工没有可用的 CLI 候选，已跳过 SDK 候选。", "AI_FALLBACK_FAILED");
+        throw new QuickCommitError("系统员工没有可用的 CLI 候选，已跳过 Wand Agent。", "AI_FALLBACK_FAILED");
     }
     const deadline = Date.now() + Math.max(1, opts.budgetMs ?? CLI_CHAIN_BUDGET_MS);
     if (chain.length === 1) {

package/dist/laya-model-manifest.d.ts

@@ -0,0 +1,11 @@
+export declare const LAYA_REPOSITORY = "aac6fef/laya-multilingual-mlx";
+export declare const LAYA_REVISION = "f2b4faf51023039425946074e2cf1361d2db11d5";
+export interface ModelFile {
+    path: string;
+    size: number;
+    sha256: string;
+}
+/** Exact upstream bytes, including tokenizer/config/identity/license, not an arbitrary HF repository. */
+export declare const LAYA_FILES: readonly ModelFile[];
+export declare const LAYA_MODEL_BYTES: number;
+export declare function layaFileUrl(file: ModelFile): string;

package/dist/laya-model-manifest.js

@@ -0,0 +1,18 @@
+export const LAYA_REPOSITORY = "aac6fef/laya-multilingual-mlx";
+export const LAYA_REVISION = "f2b4faf51023039425946074e2cf1361d2db11d5";
+/** Exact upstream bytes, including tokenizer/config/identity/license, not an arbitrary HF repository. */
+export const LAYA_FILES = [
+    { path: "model.safetensors", size: 643835426, sha256: "7fc5834af4d8fdfb268d272a9d1a66e5819a0daac98241651c4c888cc43adff1" },
+    { path: "tokenizer/tokenizer.json", size: 34363188, sha256: "609d8f4c067cd3950f88594c5a802616cea245823836ef5848ee4fc40aab5b6f" },
+    { path: "encoder/config.json", size: 1938, sha256: "83f6916d13ef0f556ac461f28308dc2bffa7ebeadee8ec9e2db5812020ea5bb4" },
+    { path: "mlx_config.json", size: 316, sha256: "20ec723e1365a268597cc7e8cd39495c5e2eb58311b925f8e8c165ec5855cc28" },
+    { path: "rl_agent_config.json", size: 473, sha256: "9a669a70961064c3c6cc76d2afb8bc5fb10dcd8349bb66e5f7b9b1afb74440d5" },
+    { path: "tokenizer/tokenizer_config.json", size: 524, sha256: "6c6b2d8e3c84ce0e671c129cd6b374b235d6f9863042a5836358d00a89bbb5a1" },
+    { path: "manifest.json", size: 1773, sha256: "deb2de8ec6b1520b74866249bda632f40501440cdac29fdd90af80a3c422c778" },
+    { path: "LICENSE", size: 10173, sha256: "a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9" },
+    { path: "NOTICE", size: 698, sha256: "f23ae8ae701f5a43e186182e387aeef00b666daed18a946fc7c9ea827b00a8fa" },
+];
+export const LAYA_MODEL_BYTES = LAYA_FILES.reduce((total, file) => total + file.size, 0);
+export function layaFileUrl(file) {
+    return `https://huggingface.co/${LAYA_REPOSITORY}/resolve/${LAYA_REVISION}/${file.path}`;
+}

package/dist/local-model-setup.d.ts

@@ -0,0 +1,46 @@
+import { type LocalDecisionConfig } from "./decision-types.js";
+import type { DecisionService } from "./decision-service.js";
+import { type ModelFile } from "./laya-model-manifest.js";
+import { runModelSetup } from "./model-setup-process.js";
+import type { SpeechService } from "./speech-service.js";
+import type { LocalModelKind, LocalModelsStatus } from "./local-model-types.js";
+export interface LocalModelSetupDeps {
+    configDir: string;
+    decisions: DecisionService;
+    speech: SpeechService;
+    decisionConfig(): LocalDecisionConfig;
+    /** Synchronous storage transaction + live service/config update, only after validation. */
+    configureDecision(config: LocalDecisionConfig): void;
+    fetch?: typeof fetch;
+    layaFiles?: readonly ModelFile[];
+    supportedLaya?: () => boolean;
+    run?: typeof runModelSetup;
+    checkRuntime?: (python: string, signal: AbortSignal) => Promise<boolean>;
+    timeoutMs?: number;
+}
+/** Deployment jobs only; existing inference owners retain their protocols, rate limits and capabilities. */
+export declare class LocalModelSetupService {
+    private readonly deps;
+    private readonly files;
+    private readonly root;
+    private readonly manifest;
+    private readonly operations;
+    private readonly jobs;
+    private sequence;
+    private disposed;
+    constructor(deps: LocalModelSetupDeps);
+    private supported;
+    private managedModel;
+    private layaModel;
+    private python;
+    status(): Promise<LocalModelsStatus>;
+    private parse;
+    start(kind: LocalModelKind, action: "download" | "initialize", raw: unknown): void;
+    private update;
+    private work;
+    private checkRuntime;
+    private installer;
+    cancel(kind: LocalModelKind): void;
+    setLayaEnabled(enabled: boolean): void;
+    dispose(): void;
+}