@lynn123411/dsh-chat-translate 1.3.2 → 1.7.0

package/lib/types/server/adapters/base.d.ts

@@ -1 +1 @@
-export type { ITranslationAdapter, PluginConfig } from '../types.ts';
+export type { ITranslationAdapter, PluginConfig, TranslateAdapterOptions, } from '../types.ts';

package/lib/types/server/adapters/openai.d.ts

@@ -1,4 +1,4 @@
-import type { ITranslationAdapter, PluginConfig } from './base.ts';
+import type { ITranslationAdapter, PluginConfig, TranslateAdapterOptions } from './base.ts';
 import type { KeyReader } from '../credentials.ts';
 export declare class OpenAiCompatibleAdapter implements ITranslationAdapter {
     readonly id = "openai";
@@ -6,5 +6,5 @@ export declare class OpenAiCompatibleAdapter implements ITranslationAdapter {
     private credentials;
     constructor(credentials: KeyReader);
     isAvailable(config: PluginConfig): boolean;
-    translate(text: string, signal: AbortSignal, config: PluginConfig): Promise<string>;
+    translate(text: string, signal: AbortSignal, config: PluginConfig, options?: TranslateAdapterOptions): Promise<string>;
 }

package/lib/types/server/cache.d.ts

@@ -6,8 +6,12 @@ export declare class LruDiskCache {
     private dirty;
     /** Legacy root-level cache file (<=1.1); moved under the plugin subdir. */
     private legacyPath;
-    constructor(maxEntries?: number);
+    /** Only the original title cache carries a pre-1.2 root-level predecessor. */
+    private hasLegacyPredecessor;
+    constructor(maxEntries?: number, fileName?: string);
     init(): Promise<void>;
+    /** Load one cache document into memory, dropping poisoned or malformed entries. */
+    private loadFile;
     get(key: string): string | undefined;
     set(key: string, value: string): void;
     private scheduleSave;

package/lib/types/server/config.d.ts

@@ -5,6 +5,15 @@ export declare const MAX_CONCURRENCY = 100;
 /** Bounds for the AI channel request timeout. */
 export declare const AI_TIMEOUT_MIN = 500;
 export declare const AI_TIMEOUT_MAX = 120000;
+/**
+ * Bounds for the think-chain request timeout. A full reasoning block can take
+ * minutes on a local model, so this budget is far larger than the short-text
+ * AI timeout and is bounded separately.
+ */
+export declare const THINK_TIMEOUT_MIN = 500;
+export declare const THINK_TIMEOUT_MAX = 900000;
+/** Entries kept in the think-chain cache pool, separate from the title pool. */
+export declare const THINK_CACHE_ENTRIES = 300;
 /**
  * The settings namespace this plugin owns. The user-editable layer lives in
  * the DSH-managed document (~/.dsh/settings.yaml) under this key; the
@@ -25,6 +34,31 @@ export interface SettingsScopeLike {
     /** Merge a patch into the user layer and persist through the provider. */
     update(patch: Partial<PluginConfig>): Promise<unknown>;
 }
+/**
+ * One path-addressed edit to a settings namespace's user section, matching
+ * DSH's `SettingsPathOp` wire shape.
+ */
+export type SettingsPathOpLike = {
+    op: 'set';
+    path: string[];
+    value: unknown;
+} | {
+    op: 'unset';
+    path: string[];
+};
+/**
+ * Provider-level write face the legacy migration needs: the settings service
+ * itself (not the per-namespace owner scope), whose `mutate` applies path ops
+ * under one revision fence.
+ */
+export interface SettingsMigrationTarget {
+    describe(): Array<{
+        ns: string;
+        user?: unknown;
+        revision?: number;
+    }>;
+    mutate(ns: string, ops: readonly SettingsPathOpLike[], expectedRevision?: number): Promise<unknown>;
+}
 /**
  * Config facade over the DSH `ctx.settings` service. No file I/O lives here
  * anymore: persistence, atomic writes, external-edit hot reload and the
@@ -64,10 +98,4 @@ export declare function sanitizePatch(input: Record<string, unknown>): Partial<P
  * or not a migration happened.
  * @returns whether any legacy values were migrated.
  */
-export declare function migrateLegacyConfigFile(settings: {
-    describe(): Array<{
-        ns: string;
-        user?: unknown;
-    }>;
-    update(ns: string, patch: Record<string, unknown>): Promise<unknown>;
-}, legacyPath: string): Promise<boolean>;
+export declare function migrateLegacyConfigFile(settings: SettingsMigrationTarget, legacyPath: string): Promise<boolean>;

package/lib/types/server/dispatcher.d.ts

@@ -1,10 +1,12 @@
-import type { TranslateItemResult } from './types.ts';
+import type { ThinkBlockResult, TranslateItemResult } from './types.ts';
 import type { ConfigManager } from './config.ts';
-import type { LruDiskCache } from './cache.ts';
+import { LruDiskCache } from './cache.ts';
 import type { KeyReader } from './credentials.ts';
 export declare class TranslationDispatcher {
     private configManager;
     private cache;
+    /** 思考正文译文的独立缓存池，与工具标题的池互不挤占。 */
+    private thinkCache;
     private credentials;
     private masking;
     private adapters;
@@ -12,7 +14,9 @@ export declare class TranslationDispatcher {
     private inFlightMap;
     private activeCount;
     private queue;
-    constructor(configManager: ConfigManager, cache: LruDiskCache, credentials?: KeyReader);
+    /** 思考链请求的串行队列尾，保证同时最多一个在途请求。 */
+    private thinkTail;
+    constructor(configManager: ConfigManager, cache: LruDiskCache, credentials?: KeyReader, thinkCache?: LruDiskCache);
     private registerAdapter;
     /**
      * Decide which channels are active for the current config, in priority order.
@@ -27,6 +31,29 @@ export declare class TranslationDispatcher {
     private computeChannels;
     translateBatch(texts: string[], forceRefresh?: boolean): Promise<TranslateItemResult[]>;
     translateOne(rawText: string, forceRefresh?: boolean): Promise<TranslateItemResult>;
+    /**
+     * 翻译思考正文的块。整条链路与工具标题翻译分离：只走 AI 通道、独立串行
+     * 队列、独立超时、独立缓存池，Bing 从不参与。
+     *
+     * 每个块先按输入上限切成片段，再各自掩码、相邻片段打包成一个请求；整批
+     * 失败时退回逐片段单发，仍失败的片段保留原文。块内任一片段失败即整块不译，
+     * 避免半中半英的段落。
+     */
+    translateThinkBlocks(blocks: string[]): Promise<ThinkBlockResult[]>;
+    /**
+     * 一整批一次请求；失败则该批逐片段单发重试一次，仍失败的片段直接放弃
+     * （保留原文），不在界面上留提示。
+     */
+    private translateThinkBatch;
+    /** 发出一次思考链请求并把结果还原成每个片段的最终译文。 */
+    private requestThinkBatch;
+    /** 串行执行器：同时最多一个在途请求，与工具标题的并发池完全独立。 */
+    private runThinkSerial;
+    /**
+     * 只读判断某通道是否还在熔断冷却期。思考链翻译只借用这个判断避开已经
+     * 出问题的服务，不改动熔断状态本身（那是工具标题通道的记账）。
+     */
+    private isChannelCoolingDown;
     testChannel(channelId: string): Promise<{
         ok: boolean;
         latencyMs: number;

package/lib/types/server/pipeline/mask-tokens.d.ts

@@ -1,24 +1,24 @@
 /**
  * Mask placeholder tokens — single source of truth for the wire format, the
- * tolerant matcher and the leftover detector.
+ * matcher and the leftover detector.
  *
- * Wire format: `__DSHMASKx<letters>_<index>__` (e.g. `__DSHMASKxkbdt_3__`).
+ * Wire format: `⟦xkbdt3⟧` — U+27E6/U+27E7 (mathematical white square brackets)
+ * around `<4-letter random id><index>`.
  *
- * Design constraints, each one a measured failure of the previous
- * `__DSH_MASK_<index>__` format against real MT engines:
+ * Design constraints, each one a measured failure of an earlier format against
+ * real MT engines:
  *
- *  - No underscore between `DSH` and `MASK`. Small models routinely drop that
- *    one separator (`__DSH_MASK_1__` -> `__DSHMASK_1__`), which defeated the
- *    old strict unmask regex and leaked the raw token into the UI.
- *  - A random letter run (`x<letters>`) makes the token collision-free against
- *    the source text and unambiguous to parse: the index is the digit run after
- *    the last `_`, so no lookbehind is needed.
- *  - The leading/trailing `__` stay: they survive MT and mark the token as
- *    emphasis to the model.
- *
- * `matchMaskToken` stays tolerant of the *legacy* format and of the spacing /
- * casing / separator damage observed in the wild, because poisoned translations
- * already sit in the on-disk and browser caches.
+ *  - No letters spelling a pronounceable word and no underscores. The previous
+ *    `__DSHMASKxkbdt_3__` format named a token that small models abbreviated
+ *    back to its recognizable core: the UI showed bare `DSH` runs instead of
+ *    the protected fragments.
+ *  - Random letters keep two mask passes in the same session from colliding and
+ *    make the token unambiguous in the translated text.
+ *  - `matchMaskToken` accepts exactly what this module emits (plus the same
+ *    token with a dropped closing bracket, an engine rewrite seen in practice).
+ *    It deliberately does NOT accept anything else: a translation that damaged
+ *    a token beyond recognition is discarded rather than repaired, because
+ *    repairing it is what put mixed or duplicated text on screen.
  */
 export declare function randomTokenId(): string;
 export interface MaskTokenFormat {
@@ -29,48 +29,54 @@ export interface MaskTokenFormat {
 }
 export declare function createMaskTokenFormat(): MaskTokenFormat;
 /**
- * Loose matcher covering every observed engine rewrite:
- *
- *   __DSHMASKxkbdt_3__      exact
- *   __DSHMASKXKBDT_3__      case folded
- *   __DSH MASK xkbdt _ 3__  spaces inserted around the structural underscores
- *   __DSHMASKkbdt_3__       the `x` id separator eaten
- *   _DSHMASKxkbdt_3_        one boundary underscore dropped
- *   __DSH_MASK_3__ / __dsh_mask_3__  legacy format (no random id)
- *
- * Both boundaries and the internal separators are optional, and the `x` id
- * separator may be replaced by whitespace/dot/hyphen. The two index branches
- * stay unambiguous: an id is always a letter run, the index always digits.
- * Capture groups: `[1] = legacy index` (undefined for the current format),
- * `[2] = token id` (undefined for the legacy format), `[3] = current index`.
+ * Scanner for complete tokens of this format. A token whose closing bracket the
+ * engine dropped is still resolved (see `matchMaskToken`), but it is not
+ * recognized as a complete token here: the space `mask()` inserts sits outside
+ * that token, and matching a truncated one would strip a space of the
+ * translation's own.
+ */
+export declare const MASK_TOKEN_PATTERN_SOURCE = "\u27E6([a-z]{4})(\\d+)\u27E7";
+/**
+ * The opening bracket, the id and the index of a token, without its closing
+ * bracket. Used to resolve a token the engine truncated.
  */
-export declare const MASK_TOKEN_PATTERN_SOURCE = "_*\\s*DSH\\s*_*\\s*MASK\\s*(?:_?\\s*(\\d+)|_*[xX]?[\\s._-]*([a-z]{2,8})\\s*_+\\s*(\\d+))(?:_{0,2}(?=[^\\w]|$))?";
+export declare const MASK_TOKEN_PREFIX_PATTERN_SOURCE = "\u27E6\\s*([a-z]{4})(\\d+)";
+/** Regex source for one retired-format token, for text that still contains one. */
+export declare const LEGACY_MASK_TOKEN_PATTERN_SOURCE = "_{1,2}DSH\\s*_*\\s*MASKx?\\s*(?:_?\\s*\\d+|_*([a-z]{2,8})\\s*_+\\s*(\\d+))_{0,2}";
 export interface MaskTokenMatch {
+    /** Index into the mask list of the `mask()` call that produced the token. */
     index: number;
-    /** false when the token carried an id from a different `mask()` call. */
-    acceptsId: boolean;
     /** Length of the matched token in characters. */
     length: number;
+    /** True when the closing bracket was missing and only the prefix matched. */
+    truncated: boolean;
 }
 /**
- * Match a single mask token at `start` in `text`.
+ * Match exactly one mask token of this format at `start` in `text`.
  *
- * `acceptsId` is false when the token's random id belongs to another masking
- * pass — the caller must then leave the token untouched, because its index
- * would resolve to unrelated content.
+ * The id must match the id of the masking pass that owns the token: every mask
+ * pass carries its own random id, so a token carrying another id belongs to
+ * another call and must not be resolved here.
  */
 export declare function matchMaskToken(text: string, start: number, id: string): MaskTokenMatch | null;
-/** True when translated text still carries a mask token of any format. */
+/** Every token of this format in `text`, left to right. */
+export declare function findMaskTokens(text: string): Array<{
+    match: MaskTokenMatch;
+    raw: string;
+}>;
+/** True when `text` still carries a token of the current format. */
 export declare function hasMaskResidue(text: string): boolean;
-/** Every mask-token-looking fragment in `text`, verbatim. */
-export declare function maskResidues(text: string): string[];
+/** True when `text` carries a token of a retired format. */
+export declare function hasLegacyMaskResidue(text: string): boolean;
 /**
- * True when `translatedText` exposes a mask token that was NOT already part of
- * `originalText`.
- *
- * A placeholder surviving the round trip is a leak; but a source text that
- * legitimately talks *about* placeholders (this plugin's own documentation,
- * say) must survive translation, so tokens the source already carried are not
- * treated as residue.
+ * Residue test for a value that must never be shown or cached: either a
+ * current-format token or any retired-format token.
+ */
+export declare function hasAnyMaskResidue(text: string): boolean;
+/**
+ * Retired-format tokens inside source text, so `mask()` can protect them with a
+ * current-format token of their own. A source that talks about the old
+ * placeholder format must survive translation, and the unmask step rejects any
+ * retired-format token it sees.
  */
-export declare function hasNewMaskResidue(originalText: string, translatedText: string): boolean;
+export declare function findLegacyMaskTokens(text: string): string[];

package/lib/types/server/pipeline/masking.d.ts

@@ -1,27 +1,50 @@
+import { hasMaskResidue } from './mask-tokens.ts';
 export interface MaskResult {
     maskedText: string;
+    /**
+     * Restore every protected fragment. Throws `MaskRestoreError` when the
+     * translated text did not carry the token sequence back intact; the caller
+     * must discard that translation instead of showing a repaired guess.
+     */
     unmask: (translatedText: string) => string;
+    /**
+     * Retired-format tokens the source itself contained. They come back on
+     * purpose and are content, so the caller's leak check must not flag them.
+     */
+    legacyFragments: string[];
+}
+/** Which spaces `mask()` inserted directly before and after a token. */
+export interface InsertedSpacing {
+    leading: boolean;
+    trailing: boolean;
+}
+export declare class MaskRestoreError extends Error {
+    readonly expectedCount: number;
+    readonly foundCount: number;
+    constructor(message: string, expectedCount: number, foundCount: number);
 }
 export declare class ContentMaskingPipeline {
     mask(text: string): MaskResult;
 }
 /**
- * Resolve every in-range mask token in `text` through `resolve`.
+ * Restore every token of `id` in `text` from `masks`.
+ *
+ * Each fragment of the pass is resolved exactly once, no matter how the engine
+ * reordered the sentence: the index embedded in the token identifies the
+ * fragment, and the random id identifies the masking pass that owns it. The
+ * spaces recorded in `inserted` are removed together with their token, so the
+ * spacing the translation produced around the fragment survives untouched.
  *
- * A token whose random id belongs to another masking pass, an out-of-range
- * index and any unmatched text are all kept verbatim; `hasMaskResidue()` on the
- * result is what flags a leaked token.
+ * @throws MaskRestoreError when the text does not carry every token exactly
+ *   once, or still shows a current-format token or a retired token that the
+ *   source did not already contain — the caller discards such a translation
+ *   instead of rendering a repaired guess.
  */
-export declare function replaceMaskTokens(text: string, id: string, resolve: (index: number) => string | undefined): string;
+export declare function replaceMaskTokens(text: string, id: string, masks: string[], inserted?: InsertedSpacing[], legacyIndexes?: ReadonlySet<number>): string;
 /**
- * True when a translated string would still show a mask token to the user.
+ * True when a translated string still shows a mask token to the user.
  * Callers use it to discard a poisoned translation (and to evict poisoned
  * cache entries written by earlier releases).
  */
 export declare function isMaskLeak(translatedText: string): boolean;
-/**
- * Same as `isMaskLeak`, but a token the source text already contained is not a
- * leak: text that talks about placeholders (this plugin's docs, a bug report)
- * must round-trip untouched.
- */
-export declare function isMaskLeakAgainst(originalText: string, translatedText: string): boolean;
+export { hasMaskResidue };

package/lib/types/server/pipeline/think.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 思考正文翻译的请求预算。每次请求的输入估算 token 上限，与本地服务的
+ * prefill 批次（MAX_NUM_BATCHED_TOKENS）保持同一量级；输出上限写进请求体的
+ * max_tokens，避免长文本把剩余上下文全部花在生成上。
+ */
+export declare const THINK_MAX_INPUT_TOKENS = 4096;
+export declare const THINK_MAX_OUTPUT_TOKENS = 8192;
+/**
+ * 保守估算一段文本占用的 token 数：汉字一字一 token，其余每三个字符一 token。
+ * 实测本机 hy-mt2-1.8b 的英文语料约为每 3.3 字符一 token，这里取 3 作为上界，
+ * 宁可把请求切得比实际需要更碎，也不让服务端收到超出预期的 prefill。
+ */
+export declare function estimateTokens(text: string): number;
+/**
+ * 把一个块切成不超过上限的片段：优先空行，其次单行，再次句末，最后硬切。
+ * 片段按原顺序拼回即为该块的完整译文。
+ */
+export declare function splitOversizedBlock(text: string, maxTokens?: number): string[];
+/** 一个待翻译的片段：属于哪个块、块内第几段、以及该片段的掩码结果。 */
+export interface ThinkPieceShell<TMask> {
+    block: number;
+    index: number;
+    text: string;
+    mask: TMask;
+}
+/** 把片段按原顺序打包成尽量少的请求，且每批不超过输入上限。 */
+export declare function packPieces<T extends {
+    text: string;
+}>(pieces: T[], maxTokens?: number): T[][];
+/**
+ * 块分隔标记：`⟪<4 letters><index>⟫`。外括号刻意与掩码占位符的 ⟦⟧ 不同形，
+ * 掩码残留检测（只认 ⟦⟧）因此不会把这个标记当成泄漏。
+ */
+export interface ThinkBatchFormat {
+    id: string;
+    token: (index: number) => string;
+}
+export declare function createThinkBatchFormat(): ThinkBatchFormat;
+/** 每个片段以单独一行标记开头，段与段之间空一行。 */
+export declare function buildBatchPayload(pieces: string[], format: ThinkBatchFormat): string;
+/**
+ * 按标记把整批译文切回每个片段。
+ *
+ * 序号必须恰好出现一次、按 0..count-1 升序、每段非空，且不得混入其它批次
+ * 的标记；任何一条不满足都返回 null，由调用方作废整批并退回单块重试。
+ */
+export declare function splitBatchTranslation(translated: string, format: ThinkBatchFormat, count: number): string[] | null;
+/** 翻译结果里是否还留着块标记（用于判定整批作废）。 */
+export declare function hasThinkBatchResidue(text: string): boolean;

package/lib/types/server/router.d.ts

@@ -1,4 +1,25 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { ConfigManager } from './config.ts';
+import type { ConnectionFetchRoute } from '@deepseek-ai/dsh-client-connection';
 import type { TranslationDispatcher } from './dispatcher.ts';
-export declare function createHttpHandler(configManager: ConfigManager, dispatcher: TranslationDispatcher): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+/**
+ * Translation proxy surface, carried by Connection's exact Fetch routes below
+ * the shared `/api` channel.
+ *
+ * Config and credentials have no HTTP endpoints: since 1.2 the settings panel
+ * reads and writes through DSH's own channels — the client `SettingsScope`
+ * service and the `credentials` Remote API — so the plugin owns exactly three
+ * routes: short-text batch translation, think-chain block translation, and the
+ * channel probe.
+ */
+/** Batch-translation route path. */
+export declare const TRANSLATE_ROUTE_PATH = "/api/dsh-chat-translate/translate";
+/** Single-channel probe route path. */
+export declare const TEST_CHANNEL_ROUTE_PATH = "/api/dsh-chat-translate/test-channel";
+/** Think-chain block translation route path. */
+export declare const THINK_ROUTE_PATH = "/api/dsh-chat-translate/translate-think";
+/**
+ * Build the plugin's exact Fetch routes.
+ * @param dispatcher - translation coordinator the routes proxy to.
+ * @param ready - settles once host-side async resources are usable; every
+ * request waits for it before touching the dispatcher.
+ */
+export declare function createFetchRoutes(dispatcher: TranslationDispatcher, ready?: Promise<unknown>): ConnectionFetchRoute[];

package/lib/types/server/types.d.ts

@@ -3,8 +3,10 @@ export interface PluginConfig {
     concurrency: number;
     timeoutMs: number;
     aiTimeoutMs: number;
+    thinkTimeoutMs: number;
     aiEnabled: boolean;
     bingEnabled: boolean;
+    thinkEnabled: boolean;
     baseUrl: string;
     model: string;
     targetLang: string;
@@ -20,9 +22,24 @@ export interface TranslateResponse {
     results: TranslateItemResult[];
     error?: string;
 }
+/** Per-request knobs an adapter may honor; channels that cannot use them ignore the argument. */
+export interface TranslateAdapterOptions {
+    /** Generation cap written into the request body; omitted lets the server decide. */
+    maxTokens?: number;
+    /** Prompt family: one plain sentence, or a marked multi-part packing. */
+    mode?: 'plain' | 'blocks';
+}
 export interface ITranslationAdapter {
     readonly id: string;
     readonly name: string;
     isAvailable(config: PluginConfig): boolean;
-    translate(text: string, signal: AbortSignal, config: PluginConfig): Promise<string>;
+    translate(text: string, signal: AbortSignal, config: PluginConfig, options?: TranslateAdapterOptions): Promise<string>;
+}
+/** One reasoning block's outcome, aligned by index with the request's block list. */
+export interface ThinkBlockResult {
+    original: string;
+    translated: string;
+    ok: boolean;
+    cached: boolean;
+    channel: string;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lynn123411/dsh-chat-translate",
-  "version": "1.3.2",
-  "description": "Tool-call & think-summary translation with dual AI (OpenAI-compatible) + Bing channels for the DeepSeek Harness Web UI",
+  "version": "1.7.0",
+  "description": "Tool-call & think-chain translation with dual AI (OpenAI-compatible) + Bing channels for the DeepSeek Harness Web UI",
   "license": "MIT",
   "author": "lynn123411",
   "repository": {
@@ -47,7 +47,9 @@
     "client": {
       "platform": "web",
       "immediately": true,
-      "inject": []
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-primitives"
+      ]
     }
   },
   "files": [
@@ -59,17 +61,22 @@
   "scripts": {
     "build": "node build.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "node scripts/test-client-wiring.mjs && node scripts/test-regression-suite.mjs && node scripts/test-channel-logic.mjs && node scripts/test-store.mjs && node scripts/test-toggle-restore.mjs"
+    "test": "node scripts/test-client-wiring.mjs && node scripts/test-regression-suite.mjs && node scripts/test-channel-logic.mjs && node scripts/test-store.mjs && node scripts/test-toggle-restore.mjs && node scripts/test-hold.mjs && node scripts/test-think-pipeline.mjs && node scripts/test-think-client.mjs",
+    "assert:lib-untracked": "node scripts/assert-lib-untracked.mjs",
+    "check": "pnpm typecheck && pnpm build && pnpm test && pnpm assert:lib-untracked"
   },
   "engines": {
-    "node": "^22.19 || >=24"
+    "node": "^22.19 || >=24",
+    "dsh": "0.1.6-alpha.2"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "4.0.2",
-    "@deepseek-ai/dsh-client-ui-renderer": "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-home-paths": "^0.1.5-rc.1",
+    "@deepseek-ai/dsh-client-connection": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-client-ui-settings": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-client-ui-slots": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-home-paths": "0.1.6-alpha.2",
     "@deepseek-ai/schemastery": "^3.18.2",
     "@eslint/js": "^9.30.0",
     "@types/node": "^22.19.0",
@@ -79,6 +86,12 @@
     "typescript": "^6.0.0"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-home-paths": "^0.1.5-rc.1"
+    "@deepseek-ai/dsh-client-ui-primitives": "*",
+    "@deepseek-ai/dsh-home-paths": "0.1.6-alpha.2"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-client-ui-primitives": {
+      "optional": true
+    }
   }
 }