hiwork-knowledge 0.1.0 → 0.2.0

package/lib/types.js

@@ -0,0 +1,112 @@
+/**
+ * `hiwork-knowledge` Host 半边的领域类型、默认值与存储域定义。
+ *
+ * 不变量：
+ *  - 存储域名字必须匹配 `/^[a-z][a-z0-9_]*$/`（不能带连字符），改名等于换一套表；
+ *  - 凭据（`apiKey`）只在 Host 半边流转：落盘在存储域、下发 WeKnora 时只进请求头，
+ *    **绝不进日志、绝不回传给 Web 半边**（`toConfigView` 只回 `hasApiKey` 布尔）；
+ *  - 默认值与本节常量一一对应，`cordis.patch.yml` 的 config 只能收紧、不能放宽
+ *    （例如把 `maxChunkChars` 调大仍受 schema 上限约束）。
+ */
+import { z } from 'zod';
+/** `ctx.storageDomain.open()` 的域标识；必须保持稳定。 */
+export const KNOWLEDGE_DOMAIN_NAME = 'hiwork_knowledge';
+export const KNOWLEDGE_DOMAIN_VERSION = 1;
+/** 设置只有一条记录，键名固定。 */
+export const KNOWLEDGE_SETTINGS_KEY = 'config';
+/** 默认后端地址：与部署文档里的域名一致（`/api/v1` 会被补齐）。 */
+export const DEFAULT_BASE_URL = 'https://hiwork-knowledge.hivery.cn/api/v1';
+export const DEFAULT_MAX_RESULTS = 8;
+export const DEFAULT_MAX_CHUNK_CHARS = 1_200;
+export const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+export const DEFAULT_CHAT_TIMEOUT_MS = 300_000;
+/** 检索结果条数上限（服务端受 `rerank_threshold` 约束，这里只做客户端截断）。 */
+export const MAX_RESULTS_CEILING = 50;
+/** 单条片段字符上限。 */
+export const MAX_CHUNK_CHARS_CEILING = 8_000;
+export const MAX_BASE_IDS = 50;
+/**
+ * 「重排未生效」的分数判据。
+ *
+ * 2026-09-18 实测（同一后端、同一知识库）：
+ *  - 租户检索配置绑好 `rerank_model_id` 时，命中分数落在 **0.43–0.59**；
+ *  - 未绑时管线 `Rerank action=skip reason="empty_model_id"`，分数是 RRF 融合值
+ *    **0.0164**（且任意查询都返回同一个分块）。
+ * 因此「最高分 < 0.05」可作为「检索结果未经重排」的稳定信号，用于自检告警。
+ */
+export const RRF_SCORE_CEILING = 0.05;
+/** 自检探针最多检查的知识库数（避免一次自检打穿后端）。 */
+export const SELF_CHECK_BASE_LIMIT = 3;
+export const knowledgeConfigSchema = z
+    .object({
+    /** WeKnora 后端地址；缺 `/api/v1` 时自动补齐。 */
+    baseUrl: z.string().trim().min(1),
+    /** 空间 API Key；空字符串表示未配置（匿名部署）。 */
+    apiKey: z.string(),
+    /** 平台级 Key 才需要（`X-Tenant-ID`）。 */
+    tenantId: z.string(),
+    /** 默认检索范围；空数组 = 凭据可见的全部知识库。 */
+    defaultBaseIds: z.array(z.string()).max(MAX_BASE_IDS),
+    maxResults: z.number().int().min(1).max(MAX_RESULTS_CEILING),
+    maxChunkChars: z.number().int().min(200).max(MAX_CHUNK_CHARS_CEILING),
+    requestTimeoutMs: z.number().int().min(1_000).max(600_000),
+    chatTimeoutMs: z.number().int().min(1_000).max(3_600_000),
+    /** 问答要走的自建 Agent ID（内置 agent 缺 model_id，会直接报错）。 */
+    agentId: z.string(),
+    /** 问答用的 chat 模型 ID（请求体 `summary_model_id`）。 */
+    chatModelId: z.string(),
+})
+    .strict();
+/** 默认配置：域名来自部署文档，凭据留空由用户在设置页填。 */
+export const DEFAULT_KNOWLEDGE_CONFIG = {
+    baseUrl: DEFAULT_BASE_URL,
+    apiKey: '',
+    tenantId: '',
+    defaultBaseIds: [],
+    maxResults: DEFAULT_MAX_RESULTS,
+    maxChunkChars: DEFAULT_MAX_CHUNK_CHARS,
+    requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
+    chatTimeoutMs: DEFAULT_CHAT_TIMEOUT_MS,
+    agentId: '',
+    chatModelId: '',
+};
+/**
+ * 把用户输入的地址补齐成 `<origin>/api/v1` 形态。
+ *
+ * 只做补路径与去尾斜杠，不猜测协议（缺协议时由 `fetch` 报错，错误信息里带上原值，
+ * 比 Host 静默拼一个 `https://` 更好排查）。
+ */
+export function normalizeBaseUrl(raw) {
+    const trimmed = raw.trim().replace(/\/+$/, '');
+    if (trimmed === '')
+        return DEFAULT_BASE_URL;
+    if (/\/api\/v1$/.test(trimmed))
+        return trimmed;
+    if (/\/api$/.test(trimmed))
+        return `${trimmed}/v1`;
+    return `${trimmed}/api/v1`;
+}
+/** Host 侧统一异常：携带稳定 code 与**不含凭据**的 message。 */
+export class KnowledgeError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'KnowledgeError';
+        this.code = code;
+    }
+}
+/** 存储域的一条设置记录（带版本戳，便于将来迁移）。 */
+export const knowledgeSettingsRecordSchema = z
+    .object({
+    version: z.literal(KNOWLEDGE_DOMAIN_VERSION),
+    config: knowledgeConfigSchema,
+})
+    .strict();
+/** `storageDomain.open()` 的域描述。 */
+export const knowledgeDomainSpec = {
+    name: KNOWLEDGE_DOMAIN_NAME,
+    version: KNOWLEDGE_DOMAIN_VERSION,
+    tables: {
+        settings: { valueSchema: knowledgeSettingsRecordSchema },
+    },
+};

package/lib/weknora.js

@@ -0,0 +1,366 @@
+/**
+ * WeKnora REST 客户端（Host 半边专用）。
+ *
+ * 设计要点：
+ *  - 只实现 M0 需要的只读端点 + 问答（SSE）；写操作（上传/删除）在 M2 才开；
+ *  - 所有出网调用都带超时：`requestTimeoutMs` 给普通请求，`chatTimeoutMs` 给问答；
+ *  - **实测行为**：后端在出错时**不主动关闭 SSE 流**（连接会一直挂着），
+ *    因此问答循环必须在收到 `response_type=error` 时立刻主动 abort；
+ *  - 解析对形状容错（`data` 既可能是数组也可能是 `{items,total}`），但**不臆造字段**：
+ *    缺字段就是 `undefined`，由上层决定如何展示；
+ *  - 错误一律映射成 `KnowledgeError`，message 里带上 HTTP 状态与 WeKnora 的原始理由，
+ *    但**永不回显 API Key**。
+ */
+import { KnowledgeError, normalizeBaseUrl, } from './types.js';
+const MAX_ERROR_BODY_CHARS = 400;
+function asRecord(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return {};
+    return value;
+}
+function str(value) {
+    return typeof value === 'string' ? value : '';
+}
+function num(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value)))
+        return Number(value);
+    return null;
+}
+/**
+ * 拆出列表：`data` 为数组时直接用；为对象时依次尝试 `items` / `list` / `records`。
+ *
+ * 实测两个端点的形状不同——`GET /knowledge-bases/:id/knowledge` 是数组，
+ * `GET /chunks/:knowledge_id` 也是数组，但同一项目里另有返回 `{items,total}` 的接口，
+ * 所以这里同时容忍两种，避免后端小版本变化就打穿。
+ */
+function toItems(payload) {
+    const root = asRecord(payload);
+    const data = root['data'];
+    if (Array.isArray(data))
+        return data.map(asRecord);
+    const container = asRecord(data);
+    for (const key of ['items', 'list', 'records']) {
+        const value = container[key];
+        if (Array.isArray(value))
+            return value.map(asRecord);
+    }
+    return [];
+}
+/** 把 WeKnora 的错误响应体收敛成一句可读理由（不含敏感字段）。 */
+function errorReason(body) {
+    const text = body.slice(0, MAX_ERROR_BODY_CHARS);
+    try {
+        const parsed = asRecord(JSON.parse(text));
+        const error = asRecord(parsed['error']);
+        const message = str(error['message']) || str(parsed['message']);
+        if (message !== '')
+            return message;
+    }
+    catch {
+        // 非 JSON：直接用截断后的原文。
+    }
+    return text.trim();
+}
+/** HTTP 状态 → 稳定错误码。 */
+function codeForStatus(status) {
+    if (status === 401 || status === 403)
+        return 'unauthorized';
+    if (status === 404)
+        return 'not-found';
+    if (status >= 400 && status < 500)
+        return 'bad-request';
+    return 'internal';
+}
+/** 合并外部取消信号与超时信号：任一触发即中止请求。 */
+function combineSignals(timeoutMs, external) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => {
+        controller.abort(new KnowledgeError('timeout', `请求超过 ${timeoutMs} ms 未完成。`));
+    }, timeoutMs);
+    const onAbort = () => {
+        controller.abort(new KnowledgeError('cancelled', '请求已取消。'));
+    };
+    if (external !== undefined) {
+        if (external.aborted)
+            onAbort();
+        else
+            external.addEventListener('abort', onAbort, { once: true });
+    }
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            clearTimeout(timer);
+            external?.removeEventListener('abort', onAbort);
+        },
+    };
+}
+/** 把底层异常归一成 `KnowledgeError`（保留超时/取消的区别）。 */
+function normalizeError(error) {
+    if (error instanceof KnowledgeError)
+        return error;
+    const name = typeof error === 'object' && error !== null && 'name' in error ? String(error.name) : '';
+    if (name === 'AbortError' || name === 'TimeoutError') {
+        const reason = typeof error === 'object' && error !== null && 'cause' in error ? error.cause : undefined;
+        if (reason instanceof KnowledgeError)
+            return reason;
+        return new KnowledgeError('timeout', '请求超时。');
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return new KnowledgeError('unreachable', message === '' ? '无法连接到 WeKnora 后端。' : `无法连接到 WeKnora 后端：${message}`);
+}
+/**
+ * 创建 WeKnora 客户端。
+ * @param config - 凭据与超时配置（`baseUrl` 会先归一化）。
+ * @param transport - 出网实现；缺省用全局 `fetch`（Node 24 自带）。
+ */
+export function createWeKnoraClient(config, transport) {
+    const baseUrl = normalizeBaseUrl(config.baseUrl);
+    const doFetch = transport ?? ((input, init) => fetch(input, init));
+    const headers = (extra) => {
+        const result = { Accept: 'application/json', ...extra };
+        if (config.apiKey !== '')
+            result['X-API-Key'] = config.apiKey;
+        if (config.tenantId !== '')
+            result['X-Tenant-ID'] = config.tenantId;
+        return result;
+    };
+    /** 普通 JSON 请求：超时 → HTTP 状态 → JSON 解析。 */
+    const requestJson = async (path, init, pick) => {
+        const url = new URL(`${baseUrl}${path}`);
+        for (const [key, value] of Object.entries(init.query ?? {}))
+            url.searchParams.set(key, value);
+        const { signal, dispose } = combineSignals(init.timeoutMs ?? config.requestTimeoutMs, init.signal);
+        try {
+            const response = await doFetch(url.toString(), {
+                method: init.method ?? 'GET',
+                headers: headers(init.body === undefined ? undefined : { 'Content-Type': 'application/json' }),
+                ...(init.body === undefined ? {} : { body: JSON.stringify(init.body) }),
+                signal,
+            });
+            if (!response.ok) {
+                const text = await response.text().catch(() => '');
+                const reason = errorReason(text);
+                throw new KnowledgeError(codeForStatus(response.status), `WeKnora 返回 ${response.status}${reason === '' ? '' : `：${reason}`}`);
+            }
+            const text = await response.text();
+            if (text.trim() === '')
+                return pick({});
+            try {
+                return pick(JSON.parse(text));
+            }
+            catch {
+                throw new KnowledgeError('internal', 'WeKnora 返回了无法解析的 JSON。');
+            }
+        }
+        catch (error) {
+            throw normalizeError(error);
+        }
+        finally {
+            dispose();
+        }
+    };
+    const mapBase = (item) => ({
+        id: str(item['id']),
+        name: str(item['name']),
+        description: str(item['description']),
+        documentCount: num(item['document_count']) ?? num(item['knowledge_count']),
+        chunkCount: num(item['chunk_count']),
+        embeddingModelId: str(item['embedding_model_id']),
+        summaryModelId: str(item['summary_model_id']),
+        updatedAt: str(item['updated_at']),
+    });
+    const mapDoc = (item) => ({
+        id: str(item['id']),
+        title: str(item['title']) || str(item['file_name']),
+        fileName: str(item['file_name']),
+        fileType: str(item['file_type']),
+        fileSize: num(item['file_size']),
+        parseStatus: str(item['parse_status']),
+        enableStatus: str(item['enable_status']),
+        summaryStatus: str(item['summary_status']),
+        folderPath: str(item['folder_path']),
+        createdAt: str(item['created_at']),
+    });
+    const mapHit = (item) => ({
+        chunkId: str(item['id']) || str(item['chunk_id']),
+        content: str(item['content']),
+        knowledgeId: str(item['knowledge_id']),
+        chunkIndex: num(item['chunk_index']),
+        knowledgeTitle: str(item['knowledge_title']),
+        fileName: str(item['knowledge_filename']),
+        score: num(item['score']),
+        chunkType: str(item['chunk_type']),
+        startAt: num(item['start_at']),
+        endAt: num(item['end_at']),
+    });
+    const mapReference = (item) => ({
+        chunkId: str(item['id']) || str(item['chunk_id']),
+        content: str(item['content']),
+        knowledgeId: str(item['knowledge_id']),
+        chunkIndex: num(item['chunk_index']),
+        knowledgeTitle: str(item['knowledge_title']),
+        chunkType: str(item['chunk_type']),
+        startAt: num(item['start_at']),
+        endAt: num(item['end_at']),
+    });
+    return {
+        listBases: signal => requestJson('/knowledge-bases', { signal }, payload => toItems(payload).map(mapBase)),
+        listDocs: (baseId, signal) => requestJson(`/knowledge-bases/${encodeURIComponent(baseId)}/knowledge`, { signal }, payload => toItems(payload).map(mapDoc)),
+        getDoc: async (knowledgeId, signal) => {
+            try {
+                const payload = await requestJson(`/knowledge/${encodeURIComponent(knowledgeId)}`, { signal }, value => asRecord(asRecord(value)['data']));
+                return Object.keys(payload).length === 0 ? null : mapDoc(payload);
+            }
+            catch (error) {
+                if (error instanceof KnowledgeError && error.code === 'not-found')
+                    return null;
+                throw error;
+            }
+        },
+        chunks: (knowledgeId, signal) => requestJson(`/chunks/${encodeURIComponent(knowledgeId)}`, { signal }, payload => toItems(payload).map(item => ({
+            chunkId: str(item['id']) || str(item['chunk_id']),
+            content: str(item['content']),
+            knowledgeId: str(item['knowledge_id']) || knowledgeId,
+            chunkIndex: num(item['chunk_index']),
+            knowledgeTitle: str(item['knowledge_title']),
+            fileName: str(item['knowledge_filename']),
+            score: num(item['score']),
+            chunkType: str(item['chunk_type']),
+            startAt: num(item['start_at']),
+            endAt: num(item['end_at']),
+        }))),
+        search: async (query, scope, signal) => {
+            const body = { query };
+            const baseIds = scope.baseIds ?? [];
+            const knowledgeIds = scope.knowledgeIds ?? [];
+            if (baseIds.length === 1)
+                body['knowledge_base_id'] = baseIds[0];
+            else if (baseIds.length > 1)
+                body['knowledge_base_ids'] = baseIds;
+            if (knowledgeIds.length > 0)
+                body['knowledge_ids'] = knowledgeIds;
+            return requestJson('/knowledge-search', { method: 'POST', body, signal, query: { resource_urls: 'handle' } }, payload => toItems(payload).map(mapHit));
+        },
+        capabilities: signal => requestJson('/system/capabilities', { signal }, payload => {
+            const caps = asRecord(asRecord(asRecord(payload)['data'])['capabilities']);
+            const result = {};
+            for (const [key, value] of Object.entries(caps)) {
+                const entry = asRecord(value);
+                const reason = str(entry['reason']);
+                result[key] = reason === '' ? { supported: entry['supported'] === true } : { supported: entry['supported'] === true, reason };
+            }
+            return result;
+        }),
+        ask: async (query, scope, signal) => {
+            const startedAt = Date.now();
+            const sessionPayload = await requestJson('/sessions', { method: 'POST', body: {}, signal }, value => asRecord(asRecord(value)['data']));
+            const sessionId = str(sessionPayload['id']);
+            if (sessionId === '')
+                throw new KnowledgeError('internal', 'WeKnora 未返回会话 ID。');
+            const body = { query };
+            const baseIds = scope.baseIds ?? [];
+            if (baseIds.length > 0)
+                body['knowledge_base_ids'] = [...baseIds];
+            // 实测：内置 agent 的 model_id 为空，/agent-chat 会直接报
+            // 「chat model is not configured」；问答必须由请求体提供 chat 模型。
+            if (config.chatModelId !== '')
+                body['summary_model_id'] = config.chatModelId;
+            const { signal: aborted, dispose } = combineSignals(config.chatTimeoutMs, signal);
+            const controller = new AbortController();
+            const relay = () => controller.abort(aborted.reason);
+            aborted.addEventListener('abort', relay, { once: true });
+            try {
+                const path = `/knowledge-chat/${encodeURIComponent(sessionId)}`;
+                const url = new URL(`${baseUrl}${path}`);
+                const response = await doFetch(url.toString(), {
+                    method: 'POST',
+                    headers: headers({ 'Content-Type': 'application/json', Accept: 'text/event-stream' }),
+                    body: JSON.stringify(body),
+                    signal: controller.signal,
+                });
+                if (!response.ok) {
+                    const text = await response.text().catch(() => '');
+                    throw new KnowledgeError(codeForStatus(response.status), `WeKnora 返回 ${response.status}${text.trim() === '' ? '' : `：${errorReason(text)}`}`);
+                }
+                if (response.body === null)
+                    throw new KnowledgeError('internal', 'WeKnora 未返回流式响应体。');
+                let answer = '';
+                let references = [];
+                const toolsUsed = [];
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = '';
+                try {
+                    for (;;) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        let index = buffer.indexOf('\n');
+                        while (index >= 0) {
+                            const line = buffer.slice(0, index).trim();
+                            buffer = buffer.slice(index + 1);
+                            index = buffer.indexOf('\n');
+                            if (!line.startsWith('data:'))
+                                continue;
+                            const raw = line.slice(5).trim();
+                            if (raw === '')
+                                continue;
+                            let frame;
+                            try {
+                                frame = asRecord(JSON.parse(raw));
+                            }
+                            catch {
+                                continue;
+                            }
+                            const type = str(frame['response_type']);
+                            if (type === 'answer')
+                                answer += str(frame['content']);
+                            else if (type === 'references') {
+                                const refs = frame['knowledge_references'];
+                                if (Array.isArray(refs))
+                                    references = refs.map(item => mapReference(asRecord(item)));
+                            }
+                            else if (type === 'tool_call') {
+                                const name = str(asRecord(frame['data'])['tool_name']) || str(frame['content']).replace(/^Calling tool:\s*/, '');
+                                if (name !== '' && !toolsUsed.includes(name))
+                                    toolsUsed.push(name);
+                            }
+                            else if (type === 'error') {
+                                // 实测后端出错后不关流：必须主动中止，否则调用方要等满超时。
+                                const message = str(frame['content']) || 'WeKnora 问答返回错误。';
+                                controller.abort(new KnowledgeError('internal', message));
+                                throw new KnowledgeError('internal', message);
+                            }
+                        }
+                    }
+                }
+                finally {
+                    await reader.cancel().catch(() => undefined);
+                }
+                return { answer, references, sessionId, toolsUsed, elapsedMs: Date.now() - startedAt };
+            }
+            catch (error) {
+                throw normalizeError(error);
+            }
+            finally {
+                aborted.removeEventListener('abort', relay);
+                dispose();
+            }
+        },
+    };
+}
+/** 自检用：不带任何业务查询地探测后端可达性与凭据（`GET /knowledge-bases`）。 */
+export async function probeConnection(config, transport, signal) {
+    const client = createWeKnoraClient(config, transport);
+    try {
+        const bases = await client.listBases(signal);
+        return { ok: true, code: 'ok', message: `已连接，可见 ${bases.length} 个知识库。`, baseCount: bases.length };
+    }
+    catch (error) {
+        const failure = error instanceof KnowledgeError ? error : normalizeError(error);
+        return { ok: false, code: failure.code, message: failure.message };
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hiwork-knowledge",
-  "version": "0.1.0",
-  "description": "HiWork 知识库插件：在中央内容区提供「知识库」入口（当前为对接海普知识库的占位页）。",
+  "version": "0.2.0",
+  "description": "HiWork 知识库插件：接腾讯 WeKnora，向 Agent 提供检索/阅读/问答工具，并在桌面端提供知识库浏览与设置。",
   "license": "UNLICENSED",
   "type": "module",
   "packageManager": "pnpm@10.28.1",
@@ -34,6 +34,7 @@
     "client": {
       "platform": "web",
       "inject": [
+        "@deepseek-ai/dsh-client-connection",
         "@deepseek-ai/dsh-client-locale",
         "@deepseek-ai/dsh-client-ui-settings",
         "@deepseek-ai/dsh-client-ui-slots"
@@ -47,25 +48,43 @@
     "build": "pnpm build:host && pnpm build:client",
     "test": "vitest run",
     "check": "pnpm typecheck && pnpm test && pnpm build",
-    "verify": "pnpm typecheck && pnpm build && pnpm test"
+    "verify": "pnpm typecheck && pnpm build && pnpm test",
+    "smoke:live": "node scripts/live-smoke.mjs"
+  },
+  "dependencies": {
+    "zod": "^4.1.5"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": ">=4.0.1 <5.0.0",
+    "@deepseek-ai/dsh-agent": ">=0.1.0-rc.5 <0.2.0",
+    "@deepseek-ai/dsh-client-connection": ">=0.1.0-rc.5 <0.2.0",
     "@deepseek-ai/dsh-client-locale": ">=0.1.0-rc.5 <0.2.0",
     "@deepseek-ai/dsh-client-ui-settings": ">=0.1.0-rc.5 <0.2.0",
     "@deepseek-ai/dsh-client-ui-slots": ">=0.1.0-rc.5 <0.2.0",
-    "react": "^18.2.0"
+    "@deepseek-ai/dsh-llm": ">=0.1.0-rc.5 <0.2.0",
+    "@deepseek-ai/dsh-storage-domain": ">=0.1.0-rc.5 <0.2.0",
+    "@deepseek-ai/dsh-tools": ">=0.1.0-rc.5 <0.2.0",
+    "react": "^18.2.0",
+    "@deepseek-ai/schemastery": ">=3.18.1 <4.0.0"
   },
   "peerDependenciesMeta": {
     "react": {
       "optional": true
+    },
+    "@deepseek-ai/dsh-agent": {
+      "optional": true
     }
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "4.0.2",
-    "@deepseek-ai/dsh-client-locale": "0.1.2-rc.1",
-    "@deepseek-ai/dsh-client-ui-settings": "0.1.2-rc.1",
-    "@deepseek-ai/dsh-client-ui-slots": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-agent": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-client-connection": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-client-locale": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-client-ui-settings": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-client-ui-slots": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-llm": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-storage-domain": "0.1.5-rc.1",
+    "@deepseek-ai/dsh-tools": "0.1.5-rc.1",
     "@types/node": "^22.0.0",
     "@types/react": "~18.3.1",
     "@types/react-dom": "~18.3.0",
@@ -74,6 +93,7 @@
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "typescript": "^5.9.0",
-    "vitest": "^3.2.0"
+    "vitest": "^3.2.0",
+    "@deepseek-ai/schemastery": "3.18.2"
   }
 }