dsh-llm-fallbacks 0.2.1 → 0.2.2

package/dist/events.d.ts

@@ -1,15 +1,29 @@
 /**
  * `fallbacks/switch` session event vocabulary (spec §5 table; plan Task 3).
  *
- * The event is appended (never rewrites history — AC-7) at every switch,
- * including the always-mode cap path: "无事件即无切换" (Global Constraint).
+ * Writing is stopped (issue #52): the plugin no longer appends this event —
+ * the apply()-time event-type registration was proven ineffective (module
+ * instance mismatch), and a session containing the event refused to load
+ * after a dsh restart. The event now exists only in history: old logs are
+ * repaired by `scripts/repair-fallbacks-switch-logs.ts`, which marks legacy
+ * events ignorable so affected sessions load again.
  * The module is type-only — the augmentation is erased at runtime; the
  * plugin's runtime behavior lives in `src/index.ts`.
  *
  * @module dsh-llm-fallbacks/events
  */
-/** Why a switch was decided (spec §5.1 `PendingSwitch.reason`). */
-export type FallbackSwitchReason = 'trigger-code' | 'always-cap';
+/**
+ * Why a switch was decided (spec §5.1 `PendingSwitch.reason`).
+ *
+ * `role-inject` is the dispatch-time reason (plan fallbacks-role-automatch
+ * Task 4): a subagent-origin agent's first request was re-routed to its
+ * resolved role's chain head. It is ADDITIVE to the failure-time reasons —
+ * the event shape stays a superset of the pre-feature payload, and existing
+ * renderers show unknown reasons raw (AC-5). Unlike `trigger-code` /
+ * `always-cap`, a `role-inject` event is NOT a failure decision: it carries
+ * no pending switch / cooldown / failure bookkeeping (no `commit()`).
+ */
+export type FallbackSwitchReason = 'trigger-code' | 'always-cap' | 'role-inject';
 /** Durable payload of one provider/model switch (spec §5 table). */
 export interface FallbacksSwitchEventData {
     turn: number;
@@ -30,7 +44,7 @@ export interface FallbacksSwitchEventData {
 }
 declare module '@deepseek-ai/dsh-session/types' {
     interface SessionEventMap {
-        /** Durable, append-only record of one provider/model switch decided by dsh-llm-fallbacks. */
+        /** Historical, append-only record of one provider/model switch decided by dsh-llm-fallbacks (no longer written — issue #52 stop-write). */
         'fallbacks/switch': FallbacksSwitchEventData;
     }
 }

package/dist/index.d.ts

@@ -13,7 +13,7 @@
  *   (**always mode included**) → `next()`; otherwise resolve role + chain,
  *   and when a candidate survives the filter (current / cooldown /
  *   step-failed / `provider/*`-missing-id) write the pending switch +
- *   cooldown + failure bookkeeping + append `fallbacks/switch`, then return
+ *   cooldown + failure bookkeeping, then return
  *   `{ kind: 'retry' }` (own recovery, no `next()`).
  * - `agent/request` waterfall: apply a pending switch after `await next()`
  *   (provider/model override, inherited `reasoningEffort` dropped — the

package/dist/index.js

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
-import * as dshSession from "@deepseek-ai/dsh-session";
 import z from "@deepseek-ai/schemastery";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 //#region .build/host/selectors.js
 var SelectorError = class extends Error {
@@ -53,7 +53,8 @@ const defaultFallbacksConfig = {
 	revertPolicy: "cooldown-expiry",
 	maxSwitchesPerStep: 8,
 	alwaysModeRetryCap: 5,
-	presets: "bundled"
+	presets: "bundled",
+	roleAutoMatch: true
 };
 const INHERIT_ROLE_ID = "inherit";
 const ROLE_ID_PATTERN = /^[a-z0-9-]{1,32}$/;
@@ -139,8 +140,101 @@ const Config = z.object({
 	revertPolicy: z.union([z.const("cooldown-expiry"), z.const("never")]).default("cooldown-expiry"),
 	maxSwitchesPerStep: z.number().default(8),
 	alwaysModeRetryCap: z.number().default(5),
-	presets: z.union([z.const("bundled"), z.const("none")]).default("bundled")
+	presets: z.union([z.const("bundled"), z.const("none")]).default("bundled"),
+	roleAutoMatch: z.boolean().default(true)
 });
+function buildAutomatchPrompt(roles, agent) {
+	const lines = [
+		"You are assigning a subagent to its best-fit role from a declared taxonomy.",
+		"",
+		"Declared roles:",
+		...roles.map((role) => `- ${role.id.trim()}: ${role.persona}`),
+		"",
+		`Agent context — origin: ${agent.session?.header?.origin ?? "root"}`
+	];
+	const preset = agent.session?.header?.agentPreset?.trim();
+	if (preset !== void 0 && preset !== "") lines.push(`agentPreset: ${preset}`);
+	lines.push("", "Reply with EXACTLY ONE of the declared role ids above, or the literal \"none\" when no role fits.", "Do not add any explanation, punctuation, or other text.");
+	return lines.join("\n");
+}
+function parseAutomatchAnswer(answer, roleIds) {
+	const cleaned = answer.replace(/^[^a-zA-Z0-9-]+/, "").replace(/[^a-zA-Z0-9-]+$/, "");
+	if (cleaned === "") return null;
+	const key = cleaned.toLowerCase();
+	if (key === "none") return null;
+	return roleIds.get(key) ?? null;
+}
+async function pickRoleByLlm(ctx, roles, agent, opts) {
+	try {
+		const list = Array.isArray(roles.list) ? roles.list : [];
+		if (list.length === 0) return null;
+		const llm = ctx.get("llm");
+		if (llm === void 0) return null;
+		const route = pickJudgmentRoute(list, agent);
+		if (route === null) return null;
+		const roleIds = new Map(list.map((role) => [role.id.trim(), role.id]));
+		const answer = await streamRoleAnswer(llm, route, buildAutomatchPrompt(list, agent), opts);
+		if (answer === null) return null;
+		return parseAutomatchAnswer(answer, roleIds);
+	} catch (error) {
+		opts.warn(`llm-fallbacks: auto-match failed — falling back to "inherit": ${describeError(error)}`);
+		return null;
+	}
+}
+function pickJudgmentRoute(roles, agent) {
+	for (const role of roles) for (const entry of role.chain ?? []) try {
+		const selector = parseSelector(entry);
+		if (selector.model !== void 0) return {
+			provider: selector.provider,
+			model: selector.model
+		};
+	} catch {}
+	const provider = agent.options?.provider;
+	const model = agent.options?.model;
+	if (provider !== void 0 && model !== void 0) return {
+		provider,
+		model
+	};
+	return null;
+}
+async function streamRoleAnswer(llm, route, prompt, opts) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? 5e3);
+	let text = "";
+	let finishKind;
+	try {
+		for await (const chunk of llm.stream({
+			provider: route.provider,
+			model: route.model,
+			system: prompt,
+			messages: [createUserMessage({
+				content: [{
+					type: "text",
+					text: "Pick the best-fit role for this agent."
+				}],
+				source: { kind: "user" }
+			})],
+			maxTokens: 32,
+			signal: controller.signal
+		})) if (chunk.type === "text-delta") text += chunk.text;
+		else if (chunk.type === "finish") {
+			finishKind = chunk.reason.kind;
+			break;
+		}
+		if (controller.signal.aborted) return null;
+		if (finishKind === "error" || finishKind === "aborted") return null;
+		return text;
+	} catch (error) {
+		if (controller.signal.aborted) opts.warn("llm-fallbacks: auto-match timed out — falling back to \"inherit\"");
+		else opts.warn(`llm-fallbacks: auto-match call failed — falling back to "inherit": ${describeError(error)}`);
+		return null;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+function describeError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
 //#endregion
 //#region .build/host/chains.js
 function resolveCandidate(entry, failing, modelExists) {
@@ -264,6 +358,29 @@ function resolveRole(agent, rules, roleIds, warn = console.warn) {
 	return INHERIT_ROLE_ID;
 }
 //#endregion
+//#region .build/host/role-resolution.js
+async function resolveRoleAtDispatch(agent, rules, roleIds, opts) {
+	const preset = agent.session?.header?.agentPreset?.trim();
+	if (preset !== void 0 && preset !== "" && preset !== "inherit") {
+		const declared = roleIds.get(preset);
+		if (declared !== void 0) return declared;
+	}
+	const role = resolveRole(agent, rules, roleIds, opts.warn);
+	if (role !== "inherit") return role;
+	if (opts.automatchEnabled && opts.automatch !== void 0) {
+		const picked = await opts.automatch(agent);
+		if (picked !== null && picked !== void 0) {
+			const declared = roleIds.get(picked.trim());
+			if (declared !== void 0) return declared;
+			opts.warn(`llm-fallbacks: auto-match returned undeclared role "${picked}" — falling back to "inherit"`);
+		}
+	}
+	return INHERIT_ROLE_ID;
+}
+function firstExactCandidate(all, wildcard) {
+	for (let index = 0; index < all.length; index += 1) if (!wildcard[index]) return all[index];
+}
+//#endregion
 //#region .build/host/cooldown.js
 var CooldownStore = class {
 	entries = new Map();
@@ -399,7 +516,8 @@ const CONFIG_KEYS = {
 	revertPolicy: true,
 	maxSwitchesPerStep: true,
 	alwaysModeRetryCap: true,
-	presets: true
+	presets: true,
+	roleAutoMatch: true
 };
 const ROLES_KEYS = {
 	list: true,
@@ -599,6 +717,7 @@ const FALLBACKS_COMMAND_LOCALES = {
 		configMaxSwitches: "单步最大切换",
 		configAlwaysCap: "always 上限",
 		configPresets: "预置",
+		configRoleAutoMatch: "角色自动匹配",
 		configEdit: "编辑：~/.dsh/profiles/<profile>/cordis.patch.yml（插件行）或 $DSH_HOME/settings.yaml（fallbacks: 分节）",
 		configEditHint: "TUI 无法修改配置——只能编辑文件"
 	},
@@ -636,6 +755,7 @@ const FALLBACKS_COMMAND_LOCALES = {
 		configMaxSwitches: "Max switches/step",
 		configAlwaysCap: "Always-mode cap",
 		configPresets: "Presets",
+		configRoleAutoMatch: "Auto-match",
 		configEdit: "Edit: ~/.dsh/profiles/<profile>/cordis.patch.yml (plugin row) or $DSH_HOME/settings.yaml (fallbacks: section)",
 		configEditHint: "TUI cannot change config — edit files only"
 	}
@@ -709,6 +829,7 @@ function fallbacksConfigText(summary, locale = "zh") {
 		`${t.configMaxSwitches}: ${summary.maxSwitchesPerStep}`,
 		`${t.configAlwaysCap}: ${summary.alwaysModeRetryCap}`,
 		`${t.configPresets}: ${summary.presets}`,
+		`${t.configRoleAutoMatch}: ${summary.roleAutoMatch ? t.configEnabled : t.configDisabled}`,
 		"",
 		t.configEdit,
 		t.configEditHint
@@ -1052,15 +1173,6 @@ function overrideConfig(seed, to) {
 }
 function apply(ctx, config = defaultFallbacksConfig) {
 	const logger = ctx.logger("llm-fallbacks");
-	const known = dshSession.KNOWN_SESSION_EVENT_TYPES;
-	let sessionEventRegistered = false;
-	if (known instanceof Set) try {
-		known.add("fallbacks/switch");
-		sessionEventRegistered = known.has("fallbacks/switch");
-	} catch {
-		sessionEventRegistered = false;
-	}
-	let sessionEventWarned = false;
 	const entry = Config(config);
 	const seeds = new FallbacksSeedManager(logger);
 	const seedsSettingsUnavailable = "llm-fallbacks: seeds: settings service is unavailable — seed roles cannot be written";
@@ -1132,6 +1244,7 @@ function apply(ctx, config = defaultFallbacksConfig) {
 	});
 	const states = new FallbackStateStore();
 	stateStores.set(ctx, states);
+	const dispatchInjected = new Set();
 	async function decide(agent, turn, step, current, reason, state) {
 		const config = source();
 		if (state !== void 0) {
@@ -1169,7 +1282,7 @@ function apply(ctx, config = defaultFallbacksConfig) {
 			reason
 		};
 	}
-	function commit(agent, state, pending, turn, step) {
+	function commit(state, pending, turn, step) {
 		const config = source();
 		const fromKey = selectorKey(pending.from.provider, pending.from.model);
 		const until = config.revertPolicy === "never" ? Number.POSITIVE_INFINITY : Date.now() + config.cooldownMs;
@@ -1178,21 +1291,6 @@ function apply(ctx, config = defaultFallbacksConfig) {
 		states.suppress(state, fromKey, until);
 		states.recordFailure(state, fromKey);
 		states.recordSwitch(state);
-		if (!sessionEventRegistered) {
-			if (!sessionEventWarned) {
-				sessionEventWarned = true;
-				logger.warn("llm-fallbacks: session event type \"fallbacks/switch\" is not registered with this harness — skipping the durable event (the switch itself is applied)");
-			}
-			return;
-		}
-		agent.session.append("fallbacks/switch", {
-			turn,
-			step,
-			from: pending.from,
-			to: pending.to,
-			role: pending.role,
-			reason: pending.reason
-		});
 	}
 	ctx.on("agent/request-error", async ({ agent, turn, step, provider, failure }, next) => {
 		const config = source();
@@ -1202,7 +1300,7 @@ function apply(ctx, config = defaultFallbacksConfig) {
 		try {
 			const pending = await decide(agent, turn, step, current, "trigger-code", states.peek(agent.id));
 			if (pending === null) return next();
-			commit(agent, states.get(agent.id), pending, turn, step);
+			commit(states.get(agent.id), pending, turn, step);
 			return { kind: "retry" };
 		} catch (error) {
 			logger.warn("llm-fallbacks: decision path failed, passing the original failure through: %s", error?.message ?? String(error));
@@ -1215,6 +1313,30 @@ function apply(ctx, config = defaultFallbacksConfig) {
 		const applied = state === void 0 ? void 0 : states.applyPending(state, turn, step);
 		if (applied !== void 0) return overrideConfig(seed, applied.to);
 		const config = source();
+		if (config.enabled && hasChains && agent.session?.header?.origin === "subagent" && !dispatchInjected.has(agent.id)) {
+			dispatchInjected.add(agent.id);
+			try {
+				const role = await resolveRoleAtDispatch(agent, config.roles.rules, roleIds, {
+					automatchEnabled: config.roleAutoMatch ?? true,
+					automatch: (agent) => pickRoleByLlm(ctx, config.roles, agent, { warn: logger.warn }),
+					warn: logger.warn
+				});
+				if (role !== "inherit") {
+					const { all, wildcard } = resolveChainViews(config.roles.list, config.rootChain, role, seed.provider, seed.model, logger.warn);
+					const head = firstExactCandidate(all, wildcard);
+					if (head !== void 0 && head.model !== void 0 && !(head.provider === seed.provider && head.model === seed.model)) {
+						const to = {
+							provider: head.provider,
+							model: head.model
+						};
+						logger.info("llm-fallbacks: agent \"%s\" role-inject role=%s model=%s/%s", agent.id, role, head.provider, head.model);
+						return overrideConfig(seed, to);
+					}
+				}
+			} catch (error) {
+				logger.warn("llm-fallbacks: dispatch role-injection failed, proceeding with the request unchanged: %s", error?.message ?? String(error));
+			}
+		}
 		if (hasChains && config.enabled && config.alwaysModeRetryCap > 0 && countRetryEvents(agent.session, turn, step, seed.provider) >= config.alwaysModeRetryCap) {
 			const decisionState = states.peek(agent.id);
 			const pending = await decide(agent, turn, step, {
@@ -1223,7 +1345,7 @@ function apply(ctx, config = defaultFallbacksConfig) {
 			}, "always-cap", decisionState);
 			if (pending !== null) {
 				const commitState = states.get(agent.id);
-				commit(agent, commitState, pending, turn, step);
+				commit(commitState, pending, turn, step);
 				const appliedCap = states.applyPending(commitState, turn, step);
 				if (appliedCap !== void 0) return overrideConfig(seed, appliedCap.to);
 			}
@@ -1237,9 +1359,11 @@ function apply(ctx, config = defaultFallbacksConfig) {
 	});
 	ctx.on("agent/disposed", ({ agent }) => {
 		states.delete(agent.id);
+		dispatchInjected.delete(agent.id);
 	});
 	ctx.effect(() => () => {
 		states.clear();
+		dispatchInjected.clear();
 	}, "llm-fallbacks: clear per-agent state");
 	const fallbacksCommandController = {
 		getSnapshot(agent) {
@@ -1268,7 +1392,8 @@ function apply(ctx, config = defaultFallbacksConfig) {
 				revertPolicy: config.revertPolicy,
 				maxSwitchesPerStep: config.maxSwitchesPerStep,
 				alwaysModeRetryCap: config.alwaysModeRetryCap,
-				presets: config.presets ?? "bundled"
+				presets: config.presets ?? "bundled",
+				roleAutoMatch: config.roleAutoMatch ?? true
 			};
 		}
 	};

package/dist/role-resolution.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Dispatch-time three-stage role resolution (plan fallbacks-role-automatch
+ * Task 2).
+ *
+ * Precedence (first hit wins):
+ * 1. explicit — `session.header.agentPreset` trimmed matches a declared role
+ *    id → that role's DECLARED RAW id (via the `roleIds` trimmed-id map, the
+ *    same canonicalization the rules path uses); the reserved `'inherit'`
+ *    and undeclared presets are NEVER dispatchable explicit roles and fall
+ *    through to rules;
+ * 2. rules — the existing `resolveRole` passthrough, unchanged (a declared
+ *    role wins; no-rule-match / an explicit rule targeting `'inherit'`
+ *    resolve to `'inherit'`);
+ * 3. auto-match — only when stage 2 resolved to `'inherit'` AND
+ *    `opts.automatchEnabled`: call `opts.automatch` with the agent. The hook
+ *    (Task 3 supplies the bounded LLM caller) MUST return a declared raw id
+ *    or `null`; the resolver defensively validates the return against
+ *    `roleIds` — an unknown id warns and resolves to `'inherit'`, never an
+ *    undeclared role. When `automatch` is undefined or `automatchEnabled`
+ *    is false the hook is skipped.
+ *
+ * `'inherit'` is the single "no specific role" outcome — reached by
+ * no-rule-match OR an explicit rule targeting `'inherit'` — and both are
+ * auto-match eligible when enabled. An operator who wants a class to never
+ * auto-match sets `roleAutoMatch: false` (→ `automatchEnabled: false`).
+ *
+ * Pure ordering logic: no config object and no LLM service inside this
+ * module — the LLM is an injectable hook owned by Task 3/4.
+ *
+ * @module dsh-llm-fallbacks/role-resolution
+ */
+import { type FallbacksRoleRule } from './config.ts';
+import { type AgentLike } from './roles.ts';
+import type { Selector } from './selectors.ts';
+export type { FallbacksRoleRule } from './config.ts';
+/** Options for {@link resolveRoleAtDispatch}. */
+export interface ResolveRoleAtDispatchOptions {
+    /**
+     * Whether the auto-match stage may run (the `roleAutoMatch` config switch).
+     * When `false`, stage 3 never runs and the outcome is identical to the
+     * rules stage alone.
+     */
+    automatchEnabled: boolean;
+    /**
+     * Auto-match hook — Task 3 supplies the bounded LLM caller; the resolver
+     * itself contains no LLM. Contract: given the agent being resolved, return
+     * a declared raw role id or `null`. The resolver defensively validates the
+     * return against `roleIds` — an unknown id warns and resolves to
+     * `'inherit'`, never an undeclared role. Skipped when undefined.
+     */
+    automatch?: (agent: AgentLike) => Promise<string | null>;
+    /** Warning sink — the decision path injects the plugin logger. */
+    warn: (message: string) => void;
+}
+/**
+ * Resolve the dispatch-time role for an agent across three ordered stages
+ * (explicit → rules → auto-match hook). Never throws on its own inputs; the
+ * hook's own rejection is deliberately NOT caught here (the Task-3/4 wiring
+ * bounds the LLM call so it never throws out of the request path).
+ *
+ * `roleIds` is the canonical trimmed-id map (`trimmed id → declared raw id`,
+ * built in `src/index.ts` apply()): every stage canonicalizes its reference
+ * by trim and returns the DECLARED RAW id, so roleDef lookups in
+ * `chains.ts` / `commands.ts` find the stored `roles.list[]` entry exactly
+ * (qc2 F-001 — no silent role inertness on padded YAML ids).
+ */
+export declare function resolveRoleAtDispatch(agent: AgentLike, rules: FallbacksRoleRule[], roleIds: ReadonlyMap<string, string>, opts: ResolveRoleAtDispatchOptions): Promise<string>;
+/**
+ * The dispatch-time chain head (plan fallbacks-role-automatch Task 4): the
+ * FIRST candidate of a `resolveChainViews` pass whose `wildcard` flag is
+ * false — an exact `provider/model` entry. `provider/*` entries are NOT
+ * dispatch injection targets (no failing model to anchor them; a guessed
+ * injection risks a hard failure whose code may sit outside `triggerCodes`),
+ * so a wildcard-only chain yields `undefined` → no injection (today's
+ * behavior). No cooldown/failed filtering and no existence probe run here —
+ * a fresh subagent's first request has no failure-scoped state (see the Task
+ * 4 decision) and exact heads are never probed. Pairs with
+ * {@link resolveChainViews}'s parallel `wildcard` provenance (`src/chains.ts`);
+ * the caller resolves the role's concatenated chain first.
+ */
+export declare function firstExactCandidate(all: readonly Selector[], wildcard: readonly boolean[]): Selector | undefined;

package/dist/roles.d.ts

@@ -2,6 +2,12 @@
  * Role resolution for fallback chains (spec §7.1; plan fallbacks-role-runtime
  * Task 1).
  *
+ * This module is the RULES stage. Dispatch-time role resolution
+ * (plan fallbacks-role-automatch) is the three-stage resolver in
+ * `role-resolution.ts` — explicit (`session.header.agentPreset`) → this
+ * rules stage → an optional auto-match hook; `AgentLike` carries the additive
+ * `session.header.agentPreset?` carrier for that explicit stage.
+ *
  * Precedence (first hit wins):
  * 1. the first `rules` entry whose specified origin/provider/model patterns
  *    all match the agent;
@@ -47,6 +53,8 @@ export interface AgentLike {
     session?: {
         header?: {
             origin?: Origin;
+            /** Dispatch-time explicit role carrier (plan fallbacks-role-automatch Task 2). */
+            agentPreset?: string;
         };
     };
 }

package/package.json

@@ -5,7 +5,7 @@
     "dsh",
     "dsh-plugin"
   ],
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -48,6 +48,7 @@
     "build-client": "tsx scripts/build-client.ts",
     "release:prepare": "tsx scripts/prepare-release.ts",
     "release:validate": "tsx scripts/validate-release-version.ts",
+    "repair:fallbacks-switch-logs": "tsx scripts/repair-fallbacks-switch-logs.ts",
     "test": "vitest run",
     "typecheck": "tsc -p tsconfig.build.json --noEmit && tsc --noEmit",
     "prepare": "pnpm run build"
@@ -57,24 +58,24 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-api-gateway": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-api-remotes": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-connection": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-ui-settings-plugins": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-ui-settings": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-web-react": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-commands": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-typert-registry": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-agent": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-api-gateway": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-api-remotes": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-connection": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-ui-settings-plugins": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-ui-settings": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-web-react": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-commands": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-typert-registry": "^0.1.0-rc.7",
     "react": "^18.2.0",
     "@deepseek-ai/schemastery": "^3.18.1"
   },