@next-open-ai/openclawx 0.8.36 → 0.8.48

package/dist/server/config/config.controller.d.ts

@@ -1,7 +1,9 @@
 import { ConfigService, AppConfig } from './config.service.js';
+import { LocalModelsService } from './local-models.service.js';
 export declare class ConfigController {
     private readonly configService;
-    constructor(configService: ConfigService);
+    private readonly localModelsService;
+    constructor(configService: ConfigService, localModelsService: LocalModelsService);
     getConfig(): Promise<{
         success: boolean;
         data: {
@@ -16,7 +18,7 @@ export declare class ConfigController {
             loginUsername?: string;
             providers: {
                 [key: string]: {
-                    apiKey? /** OpenCode 免费/推荐模型列表，供代理配置界面下拉选择（本地/远程模式默认模型） */: string;
+                    apiKey?: string;
                     baseUrl?: string;
                     alias?: string;
                 };
@@ -39,6 +41,19 @@ export declare class ConfigController {
                 embeddingModelItemCode?: string;
             };
             channels?: import("../../core/config/desktop-config.js").ChannelsConfig;
+            tools?: {
+                webSearch?: {
+                    defaultProvider?: "brave" | "duck-duck-scrape";
+                    providers?: {
+                        brave?: {
+                            apiKey?: string;
+                        };
+                    };
+                    timeoutSeconds?: number;
+                    cacheTtlMinutes?: number;
+                    maxResults?: number;
+                };
+            };
         };
     }>;
     updateConfig(updates: Partial<AppConfig>): Promise<{
@@ -55,7 +70,7 @@ export declare class ConfigController {
             loginUsername?: string;
             providers: {
                 [key: string]: {
-                    apiKey? /** OpenCode 免费/推荐模型列表，供代理配置界面下拉选择（本地/远程模式默认模型） */: string;
+                    apiKey?: string;
                     baseUrl?: string;
                     alias?: string;
                 };
@@ -78,6 +93,19 @@ export declare class ConfigController {
                 embeddingModelItemCode?: string;
             };
             channels?: import("../../core/config/desktop-config.js").ChannelsConfig;
+            tools?: {
+                webSearch?: {
+                    defaultProvider?: "brave" | "duck-duck-scrape";
+                    providers?: {
+                        brave?: {
+                            apiKey?: string;
+                        };
+                    };
+                    timeoutSeconds?: number;
+                    cacheTtlMinutes?: number;
+                    maxResults?: number;
+                };
+            };
         };
     }>;
     getProviders(): Promise<{
@@ -86,7 +114,7 @@ export declare class ConfigController {
     }>;
     getProviderSupport(): Promise<{
         success: boolean;
-        data: import("../../index.js").ProviderSupport;
+        data: import("../../core/config/provider-support-default.js").ProviderSupport;
     }>;
     getModels(provider: string, type?: string): Promise<{
         success: boolean;
@@ -101,4 +129,56 @@ export declare class ConfigController {
         success: boolean;
         data: import("../../core/agent/proxy/adapters/opencode-free-models.js").OpenCodeFreeModelOption[];
     };
+    /** 列出本地已缓存的 GGUF 模型文件 */
+    listLocalModels(): Promise<{
+        success: boolean;
+        data: import("./local-models.service.js").LocalModelInfo[];
+    }>;
+    /** 推荐的 GGUF 模型列表（来自 preset，与已安装展示名称一致） */
+    getRecommendedModels(): Promise<{
+        success: boolean;
+        data: import("./local-models.service.js").RecommendedModel[];
+    }>;
+    /** 仅返回尚未安装的推荐模型（已安装的不显示在下载区） */
+    getRecommendedToDownload(): Promise<{
+        success: boolean;
+        data: import("./local-models.service.js").RecommendedModel[];
+    }>;
+    /** 本地模型服务状态：是否可用、不可用原因、当前 baseUrl */
+    getLocalLlmStatus(): {
+        success: boolean;
+        data: {
+            available: boolean;
+            error: string | undefined;
+            baseUrl: string | undefined;
+        };
+    };
+    /** 启动本地模型服务：可选指定 LLM 与 Embedding 模型（文件名或 hf: URI），先停后启 */
+    startLocalLlm(body: {
+        llmModelUri?: string;
+        embeddingModelUri?: string;
+    }): Promise<{
+        success: boolean;
+        data: {
+            baseUrl: string;
+        };
+    }>;
+    /** 开始后台下载模型（立即返回，进度通过 GET local-models/progress/:uri 轮询） */
+    startDownload(body: {
+        modelUri: string;
+    }): Promise<{
+        success: boolean;
+        data: {
+            filename: string;
+        };
+    }>;
+    /** 查询下载进度 */
+    getDownloadProgress(uri: string): {
+        success: boolean;
+        data: import("./local-models.service.js").DownloadProgress | null;
+    };
+    /** 删除本地缓存的 GGUF 模型文件 */
+    deleteLocalModel(filename: string): Promise<{
+        success: boolean;
+    }>;
 }

package/dist/server/config/config.controller.js

@@ -10,13 +10,19 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Controller, Get, Put, Body, Param, Query } from '@nestjs/common';
+import { Controller, Get, Put, Body, Param, Query, Delete, Post } from '@nestjs/common';
 import { OPENCODE_FREE_MODELS } from '../../core/agent/proxy/adapters/opencode-free-models.js';
+import { loadDesktopAgentConfig } from '../../core/config/desktop-config.js';
+import { startLocalLlmServer, stopLocalLlmServer } from '../../core/local-llm-server/index.js';
+import { toModelPathForStart, LOCAL_LLM_CACHE_DIR } from '../../core/local-llm-server/model-resolve.js';
 import { ConfigService } from './config.service.js';
+import { LocalModelsService } from './local-models.service.js';
 let ConfigController = class ConfigController {
     configService;
-    constructor(configService) {
+    localModelsService;
+    constructor(configService, localModelsService) {
         this.configService = configService;
+        this.localModelsService = localModelsService;
     }
     async getConfig() {
         const config = await this.configService.getConfig();
@@ -62,6 +68,79 @@ let ConfigController = class ConfigController {
             data: OPENCODE_FREE_MODELS,
         };
     }
+    // ─── 本地模型管理（node-llama-cpp GGUF）────────────────────────────────────
+    /** 列出本地已缓存的 GGUF 模型文件 */
+    async listLocalModels() {
+        return { success: true, data: await this.localModelsService.listModels() };
+    }
+    /** 推荐的 GGUF 模型列表（来自 preset，与已安装展示名称一致） */
+    async getRecommendedModels() {
+        const data = await this.localModelsService.getRecommendedModels();
+        return { success: true, data };
+    }
+    /** 仅返回尚未安装的推荐模型（已安装的不显示在下载区） */
+    async getRecommendedToDownload() {
+        const data = await this.localModelsService.getRecommendedToDownload();
+        return { success: true, data };
+    }
+    /** 本地模型服务状态：是否可用、不可用原因、当前 baseUrl */
+    getLocalLlmStatus() {
+        const baseUrl = process.env.LOCAL_LLM_BASE_URL;
+        const error = process.env.LOCAL_LLM_START_FAILED;
+        const available = !!baseUrl;
+        return {
+            success: true,
+            data: { available, error: error || undefined, baseUrl: baseUrl || undefined },
+        };
+    }
+    /** 启动本地模型服务：可选指定 LLM 与 Embedding 模型（文件名或 hf: URI），先停后启 */
+    async startLocalLlm(body) {
+        stopLocalLlmServer();
+        delete process.env.LOCAL_LLM_BASE_URL;
+        delete process.env.LOCAL_LLM_START_FAILED;
+        let contextSize = 32768;
+        try {
+            const defaultAgent = await loadDesktopAgentConfig('default');
+            if (defaultAgent?.contextSize != null && defaultAgent.contextSize > 0) {
+                contextSize = defaultAgent.contextSize;
+            }
+        }
+        catch {
+            // ignore
+        }
+        const llmPath = body.llmModelUri?.trim();
+        const embPath = body.embeddingModelUri?.trim();
+        const opts = {
+            ...(llmPath ? { llmModelPath: toModelPathForStart(llmPath, LOCAL_LLM_CACHE_DIR) } : {}),
+            ...(embPath ? { embeddingModelPath: toModelPathForStart(embPath, LOCAL_LLM_CACHE_DIR) } : {}),
+            contextSize,
+        };
+        try {
+            const handle = await startLocalLlmServer(opts);
+            process.env.LOCAL_LLM_BASE_URL = handle.baseUrl;
+            return { success: true, data: { baseUrl: handle.baseUrl } };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            process.env.LOCAL_LLM_START_FAILED = msg;
+            throw new Error(msg);
+        }
+    }
+    /** 开始后台下载模型（立即返回，进度通过 GET local-models/progress/:uri 轮询） */
+    async startDownload(body) {
+        const result = await this.localModelsService.startDownload(body.modelUri);
+        return { success: true, data: result };
+    }
+    /** 查询下载进度 */
+    getDownloadProgress(uri) {
+        const progress = this.localModelsService.getDownloadProgress(uri);
+        return { success: true, data: progress };
+    }
+    /** 删除本地缓存的 GGUF 模型文件 */
+    async deleteLocalModel(filename) {
+        await this.localModelsService.deleteModel(filename);
+        return { success: true };
+    }
 };
 __decorate([
     Get(),
@@ -102,8 +181,61 @@ __decorate([
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
 ], ConfigController.prototype, "getOpencodeFreeModels", null);
+__decorate([
+    Get('local-models'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ConfigController.prototype, "listLocalModels", null);
+__decorate([
+    Get('local-models/recommended'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ConfigController.prototype, "getRecommendedModels", null);
+__decorate([
+    Get('local-models/recommended-to-download'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ConfigController.prototype, "getRecommendedToDownload", null);
+__decorate([
+    Get('local-models/status'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ConfigController.prototype, "getLocalLlmStatus", null);
+__decorate([
+    Post('local-models/start'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], ConfigController.prototype, "startLocalLlm", null);
+__decorate([
+    Post('local-models/download'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], ConfigController.prototype, "startDownload", null);
+__decorate([
+    Get('local-models/progress'),
+    __param(0, Query('uri')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], ConfigController.prototype, "getDownloadProgress", null);
+__decorate([
+    Delete('local-models/:filename'),
+    __param(0, Param('filename')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], ConfigController.prototype, "deleteLocalModel", null);
 ConfigController = __decorate([
     Controller('config'),
-    __metadata("design:paramtypes", [ConfigService])
+    __metadata("design:paramtypes", [ConfigService,
+        LocalModelsService])
 ], ConfigController);
 export { ConfigController };

package/dist/server/config/config.module.js

@@ -7,6 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Module, forwardRef } from '@nestjs/common';
 import { ConfigController } from './config.controller.js';
 import { ConfigService } from './config.service.js';
+import { LocalModelsService } from './local-models.service.js';
 import { AgentConfigModule } from '../agent-config/agent-config.module.js';
 let ConfigModule = class ConfigModule {
 };
@@ -14,8 +15,8 @@ ConfigModule = __decorate([
     Module({
         imports: [forwardRef(() => AgentConfigModule)],
         controllers: [ConfigController],
-        providers: [ConfigService],
-        exports: [ConfigService],
+        providers: [ConfigService, LocalModelsService],
+        exports: [ConfigService, LocalModelsService],
     })
 ], ConfigModule);
 export { ConfigModule };

package/dist/server/config/config.service.d.ts

@@ -71,6 +71,20 @@ export interface AppConfig {
     };
     /** 通道配置：飞书、Telegram 等 token/key */
     channels?: ChannelsConfig;
+    /** 工具相关：在线搜索等，Brave API Key 存于 providers.brave.apiKey */
+    tools?: {
+        webSearch?: {
+            defaultProvider?: 'brave' | 'duck-duck-scrape';
+            providers?: {
+                brave?: {
+                    apiKey?: string;
+                };
+            };
+            timeoutSeconds?: number;
+            cacheTtlMinutes?: number;
+            maxResults?: number;
+        };
+    };
 }
 export declare class ConfigService {
     private readonly agentConfigService;

package/dist/server/config/local-models.service.d.ts

@@ -0,0 +1,52 @@
+export interface RecommendedModel {
+    id: string;
+    name: string;
+    type: 'llm' | 'embedding';
+    sizeHint: string;
+}
+export interface LocalModelInfo {
+    filename: string;
+    /** 文件大小（字节） */
+    size: number;
+    /** 最后修改时间 ISO 字符串 */
+    updatedAt: string;
+    /** 推断的模型类型：llm / embedding（根据文件名关键词） */
+    inferredType: 'llm' | 'embedding' | 'unknown';
+    /** 与推荐列表一致的展示名称（能匹配到预设时），否则为 filename */
+    displayName: string;
+}
+export interface DownloadProgress {
+    status: string;
+    completed?: number;
+    total?: number;
+    percent?: number;
+}
+export declare class LocalModelsService {
+    private readonly cacheDir;
+    private recommendedCache;
+    /** 正在下载的任务：modelUri → 进度 */
+    private downloadingMap;
+    constructor();
+    /** 从 presets/recommended-local-models.json 加载推荐列表，失败则用内置默认 */
+    private getRecommendedModelsFromPreset;
+    /** 列出本地已缓存的 GGUF 模型文件，displayName 与推荐列表一致（来自 preset 匹配） */
+    listModels(): Promise<LocalModelInfo[]>;
+    /** 删除本地缓存的 GGUF 模型文件 */
+    deleteModel(filename: string): Promise<void>;
+    /** 获取推荐模型列表（来自 preset，与已安装展示名称一致） */
+    getRecommendedModels(): Promise<RecommendedModel[]>;
+    /** 仅返回尚未安装的推荐模型；已安装的视为「推荐列表中的一员」不再出现在备下载区 */
+    getRecommendedToDownload(): Promise<RecommendedModel[]>;
+    /** 检查指定模型（uri 或文件名）是否已在缓存目录存在 */
+    isModelFilePresent(modelIdOrUri: string): boolean;
+    /** 获取某个 modelUri 的下载进度（不存在则表示未在下载） */
+    getDownloadProgress(modelUri: string): DownloadProgress | null;
+    /**
+     * 后台下载模型（通过 node-llama-cpp resolveModelFile）。
+     * 返回后立即响应，进度通过 getDownloadProgress 轮询获取。
+     */
+    startDownload(modelUri: string): Promise<{
+        filename: string;
+    }>;
+    private runDownload;
+}

package/dist/server/config/local-models.service.js

@@ -0,0 +1,211 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+/**
+ * 本地 GGUF 模型管理服务。
+ * 负责列出、下载（通过 node-llama-cpp resolveModelFile）、删除本地缓存的 GGUF 模型文件。
+ * 推荐列表从 presets/recommended-local-models.json 加载，已安装的与推荐使用同一套展示名称且已安装的不再出现在「备下载」列表。
+ * 模型缓存目录：~/.cache/llama
+ */
+import { Injectable } from '@nestjs/common';
+import { readdir, stat, unlink, readFile } from 'node:fs/promises';
+import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
+import { existsSync, mkdirSync } from 'node:fs';
+import { modelUriToFilename, modelUriBasename } from '../../core/local-llm-server/model-resolve.js';
+/** 根据文件名推断模型类型 */
+function inferModelType(filename) {
+    const lower = filename.toLowerCase();
+    if (lower.includes('embed') || lower.includes('bge') || lower.includes('e5-'))
+        return 'embedding';
+    return 'llm';
+}
+const PRESET_FILENAME = 'recommended-local-models.json';
+const DEFAULT_RECOMMENDED = [
+    { id: 'hf:Qwen/Qwen3-4B-GGUF/Qwen3-4B-Q4_K_M.gguf', name: 'Qwen3 4B Q4_K_M', type: 'llm', sizeHint: '~2.5GB' },
+    { id: 'hf:Qwen/Qwen3-7B-GGUF/Qwen3-7B-Q4_K_M.gguf', name: 'Qwen3 7B Q4_K_M', type: 'llm', sizeHint: '~4.5GB' },
+    { id: 'hf:Qwen/Qwen3-14B-GGUF/Qwen3-14B-Q4_K_M.gguf', name: 'Qwen3 14B Q4_K_M', type: 'llm', sizeHint: '~8.5GB' },
+    { id: 'hf:ggml-org/embeddinggemma-300M-GGUF/embeddinggemma-300M-Q8_0.gguf', name: 'EmbeddingGemma 300M Q8 (768维)', type: 'embedding', sizeHint: '~300MB' },
+    { id: 'hf:gpustack/bge-m3-GGUF/bge-m3-Q8_0.gguf', name: 'BGE-M3 Q8 多语言 (1024维)', type: 'embedding', sizeHint: '~1.2GB' },
+    { id: 'hf:mixedbread-ai/mxbai-embed-large-v1-GGUF/mxbai-embed-large-v1-f16.gguf', name: 'MxBai Embed Large v1 (1024维)', type: 'embedding', sizeHint: '~670MB' },
+];
+function getPresetsDir() {
+    return process.env.OPENBOT_PRESETS_DIR || join(process.cwd(), 'presets');
+}
+/** 推荐项是否对应已安装文件（精确预测名 或 安装文件名以 uri 末尾文件名结尾，兼容不同 node-llama-cpp 命名） */
+function recommendedMatchesInstalled(rec, installedFilenames) {
+    const predicted = modelUriToFilename(rec.id);
+    if (installedFilenames.has(predicted))
+        return true;
+    const suffix = modelUriBasename(rec.id);
+    return Array.from(installedFilenames).some((f) => f.endsWith(suffix) || f === suffix);
+}
+/** 已安装文件名在预设中对应的展示名，若无匹配则返回 filename */
+function displayNameForFilename(filename, recommended) {
+    for (const rec of recommended) {
+        const predicted = modelUriToFilename(rec.id);
+        if (filename === predicted)
+            return rec.name;
+        const uriBase = modelUriBasename(rec.id);
+        if (uriBase && filename.endsWith(uriBase))
+            return rec.name;
+    }
+    return filename;
+}
+let LocalModelsService = class LocalModelsService {
+    cacheDir;
+    recommendedCache = null;
+    /** 正在下载的任务：modelUri → 进度 */
+    downloadingMap = new Map();
+    constructor() {
+        this.cacheDir = join(homedir(), '.cache', 'llama');
+        if (!existsSync(this.cacheDir)) {
+            mkdirSync(this.cacheDir, { recursive: true });
+        }
+    }
+    /** 从 presets/recommended-local-models.json 加载推荐列表，失败则用内置默认 */
+    async getRecommendedModelsFromPreset() {
+        if (this.recommendedCache)
+            return this.recommendedCache;
+        const presetPath = join(getPresetsDir(), PRESET_FILENAME);
+        try {
+            if (existsSync(presetPath)) {
+                const raw = await readFile(presetPath, 'utf-8');
+                const data = JSON.parse(raw);
+                if (Array.isArray(data.models) && data.models.length > 0) {
+                    this.recommendedCache = data.models;
+                    return this.recommendedCache;
+                }
+            }
+        }
+        catch {
+            // ignore, fallback to default
+        }
+        this.recommendedCache = DEFAULT_RECOMMENDED;
+        return this.recommendedCache;
+    }
+    /** 列出本地已缓存的 GGUF 模型文件，displayName 与推荐列表一致（来自 preset 匹配） */
+    async listModels() {
+        try {
+            const recommended = await this.getRecommendedModelsFromPreset();
+            const files = await readdir(this.cacheDir);
+            const ggufFiles = files.filter((f) => f.endsWith('.gguf'));
+            const infos = await Promise.all(ggufFiles.map(async (f) => {
+                const filePath = join(this.cacheDir, f);
+                const s = await stat(filePath);
+                return {
+                    filename: f,
+                    size: s.size,
+                    updatedAt: s.mtime.toISOString(),
+                    inferredType: inferModelType(f),
+                    displayName: displayNameForFilename(f, recommended),
+                };
+            }));
+            return infos.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        }
+        catch {
+            return [];
+        }
+    }
+    /** 删除本地缓存的 GGUF 模型文件 */
+    async deleteModel(filename) {
+        // 安全检查：只允许删除 .gguf 文件，且不含路径分隔符
+        if (!filename.endsWith('.gguf') || filename.includes('/') || filename.includes('\\')) {
+            throw new Error('非法文件名');
+        }
+        const filePath = join(this.cacheDir, filename);
+        if (!existsSync(filePath))
+            throw new Error(`文件不存在: ${filename}`);
+        await unlink(filePath);
+    }
+    /** 获取推荐模型列表（来自 preset，与已安装展示名称一致） */
+    async getRecommendedModels() {
+        return this.getRecommendedModelsFromPreset();
+    }
+    /** 仅返回尚未安装的推荐模型；已安装的视为「推荐列表中的一员」不再出现在备下载区 */
+    async getRecommendedToDownload() {
+        const [recommended, installed] = await Promise.all([
+            this.getRecommendedModelsFromPreset(),
+            this.listModels(),
+        ]);
+        const installedFilenames = new Set(installed.map((m) => m.filename));
+        return recommended.filter((rec) => !recommendedMatchesInstalled(rec, installedFilenames));
+    }
+    /** 检查指定模型（uri 或文件名）是否已在缓存目录存在 */
+    isModelFilePresent(modelIdOrUri) {
+        const filename = modelUriToFilename(modelIdOrUri);
+        if (!filename || !filename.endsWith('.gguf'))
+            return false;
+        return existsSync(join(this.cacheDir, filename));
+    }
+    /** 获取某个 modelUri 的下载进度（不存在则表示未在下载） */
+    getDownloadProgress(modelUri) {
+        return this.downloadingMap.get(modelUri) ?? null;
+    }
+    /**
+     * 后台下载模型（通过 node-llama-cpp resolveModelFile）。
+     * 返回后立即响应，进度通过 getDownloadProgress 轮询获取。
+     */
+    async startDownload(modelUri) {
+        if (this.downloadingMap.has(modelUri)) {
+            // 已在下载中，返回预期文件名
+            return { filename: modelUriToFilename(modelUri) };
+        }
+        this.downloadingMap.set(modelUri, { status: '准备下载...' });
+        // 后台异步执行，不 await
+        this.runDownload(modelUri).catch((e) => {
+            this.downloadingMap.set(modelUri, { status: `下载失败: ${e?.message ?? e}` });
+        });
+        return { filename: modelUriToFilename(modelUri) };
+    }
+    async runDownload(modelUri) {
+        try {
+            const { resolveModelFile } = await import('node-llama-cpp');
+            this.downloadingMap.set(modelUri, { status: '解析模型地址...' });
+            // 从环境变量读取 Hugging Face token（可选）
+            const hfToken = process.env.HF_TOKEN || process.env.HUGGING_FACE_TOKEN;
+            const options = {
+                directory: this.cacheDir,
+                onProgress: ({ downloadedSize, totalSize }) => {
+                    const percent = totalSize ? Math.round((downloadedSize / totalSize) * 100) : 0;
+                    this.downloadingMap.set(modelUri, {
+                        status: '下载中',
+                        completed: downloadedSize,
+                        total: totalSize,
+                        percent,
+                    });
+                },
+            };
+            // 如果有 token，添加到请求头
+            if (hfToken) {
+                options.headers = { Authorization: `Bearer ${hfToken}` };
+            }
+            const resolved = await resolveModelFile(modelUri, options);
+            const filename = basename(resolved);
+            this.downloadingMap.set(modelUri, { status: `完成: ${filename}`, percent: 100 });
+            // 5 秒后清除进度记录
+            setTimeout(() => this.downloadingMap.delete(modelUri), 5000);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            let errorMsg = `失败: ${msg}`;
+            // 如果是 401 错误，提供更友好的提示
+            if (msg.includes('401') || msg.includes('Unauthorized')) {
+                errorMsg = '下载失败: 需要 Hugging Face Token。请设置环境变量 HF_TOKEN 或 HUGGING_FACE_TOKEN';
+            }
+            this.downloadingMap.set(modelUri, { status: errorMsg });
+            throw e;
+        }
+    }
+};
+LocalModelsService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [])
+], LocalModelsService);
+export { LocalModelsService };

package/package.json

@@ -3,7 +3,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.8.36",
+    "version": "0.8.48",
     "description": "OpenClawX - A professional desktop application for managing and executing AI agents with real-time chat, session management, and skills browsing.",
     "type": "module",
     "main": "dist/index.js",
@@ -26,6 +26,7 @@
         "openbot": "./dist/cli/cli.js"
     },
     "dependencies": {
+        "@instantlyeasy/claude-code-sdk-ts": "^0.3.3",
         "@larksuiteoapi/node-sdk": "^1.59.0",
         "@mariozechner/pi-ai": "^0.51.2",
         "@mariozechner/pi-coding-agent": "^0.51.2",
@@ -41,6 +42,7 @@
         "commander": "^14.0.2",
         "croner": "^9.1.0",
         "dingtalk-stream": "^2.1.4",
+        "duck-duck-scrape": "^2.2.7",
         "multer": "^1.4.5-lts.1",
         "node-llama-cpp": "^3.15.0",
         "qrcode": "^1.5.4",