@deepseek-ai/dsh-session-log-deepseek 0.1.7-alpha.2 → 0.1.7-rc.2

package/README.i18n.yaml

@@ -1,6 +1,46 @@
-# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
-# side as of the last confirmed-consistent state. Both languages carry equal authority;
-# after editing either side, bring the other along and re-record with:
+# Bilingual-pair consistency record for README.md (docs/i18n/README.md): per heading
+# section, a hash of its English and Chinese blocks outside code blocks and generated regions.
+# After editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/session/session-log-deepseek/README.md
-README.md: 27396f96191e0f88268558a1426b28e0b7dc6f12
-README.zh.md: a2840223f043283b0f7f0176108d23a5c94213ef
+/:
+  en: 29b2294131f1a592
+  zh: 6d7f4fa9e1f46943
+/deepseek-ai-dsh-session-log-deepseek:
+  en: 6d991785cbfd70ae
+  zh: 0918e2462821cde4
+/deepseek-ai-dsh-session-log-deepseek/summary:
+  en: 19c182dbd7d8e064
+  zh: 51c043d6ea52db0d
+/deepseek-ai-dsh-session-log-deepseek/table-of-contents:
+  en: e2aa29e41bc101c4
+  zh: 2ef629f2a444bc13
+/deepseek-ai-dsh-session-log-deepseek/configuration:
+  en: 1e8712ec4f0fefcc
+  zh: 5ffe754b2cefdd21
+/deepseek-ai-dsh-session-log-deepseek/request-field:
+  en: 197814e2c48d05b5
+  zh: f4616fb23a3c7a32
+/deepseek-ai-dsh-session-log-deepseek/acceptance-and-retry:
+  en: 3688592c474b3e95
+  zh: 5e83afeb9aa9e9e3
+/deepseek-ai-dsh-session-log-deepseek/model-experience:
+  en: 215e7ba838619b7b
+  zh: a311da3843709f90
+/deepseek-ai-dsh-session-log-deepseek/model-experience/session-log-metadata:
+  en: 468b9eaee350f6e2
+  zh: c192ad6228e7044d
+/deepseek-ai-dsh-session-log-deepseek/model-experience/session-log-metadata/what-the-model-sees:
+  en: 89fef23a54a0f9d6
+  zh: fd17806f1df6083e
+/deepseek-ai-dsh-session-log-deepseek/model-experience/session-log-metadata/token-effect:
+  en: 6a1bb7bbc7db7f06
+  zh: 94ddaa773b7538f7
+/deepseek-ai-dsh-session-log-deepseek/model-experience/session-log-metadata/kv-cache-effect:
+  en: dcf00aa1af688f09
+  zh: df5851d66c3a6b4f
+/deepseek-ai-dsh-session-log-deepseek/known-limitations-and-deferred-work:
+  en: 249ef8dbc237a0c2
+  zh: c169d64ce9ab984c
+/deepseek-ai-dsh-session-log-deepseek/known-limitations-and-deferred-work/dev-note:
+  en: e67f633dc6fe7773
+  zh: e88aeb617ffb74ea

package/README.md

@@ -28,18 +28,21 @@ Incremental canonical session-log upload for official DeepSeek LLM API requests.
 | Key | Default | Meaning |
 |---|---:|---|
 | `enabled` | `true` | Register the `dsh_session_log` contribution. Set it to `false` to stop Session-log upload. |
+| `maxBytes` | 8 MiB | Largest serialized `dsh_session_log` field, in UTF-8 bytes, that one request carries. |
 
 Shipped profiles mount the plugin, so the default configuration registers the request field and appends the acceptance watermark; an overlay opts out with `enabled: false`.
 
 <a id="request-field"></a>
 ## Request field
 
-For a request carrying a live `sessionId`, the plugin folds the greatest accepted watermark for that exact Session format generation, snapshots `Session.events`, and sends the contiguous suffix after the watermark. A process-local fold scans each event once and consumes later appends incrementally; restart and HMR rebuild it from the durable log. The version-1 field contains `sessionFormatVersion`, a raw session header (`seedLength` is present only for a seeded Session), numeric `afterSeq` and `throughSeq`, and every complete canonical event translated to raw-number envelope fields. Forked sessions ignore inherited parent watermarks because both the recorded Session id and format generation must match the request source. Surface events require `surfaceOp`, with numeric `startSeq` and `endSeq` for replacements; only system, user, and tool events may carry `sourceEventSeqs`. Assistant provider metadata stays in the embedded stream, and log-only events carry neither metadata field.
+For a request carrying a live `sessionId`, the plugin folds the greatest accepted watermark for that exact Session format generation, snapshots `Session.events`, and sends the longest contiguous run after the watermark that fits `maxBytes`. A process-local fold scans each event once and consumes later appends incrementally; restart and HMR rebuild it from the durable log. The version-1 field contains `sessionFormatVersion`, a raw session header (`seedLength` is present only for a seeded Session), numeric `afterSeq` and `throughSeq`, and every complete canonical event translated to raw-number envelope fields. Forked sessions ignore inherited parent watermarks because both the recorded Session id and format generation must match the request source. Surface events require `surfaceOp`, with numeric `startSeq` and `endSeq` for replacements; only system, user, and tool events may carry `sourceEventSeqs`. Assistant provider metadata stays in the embedded stream, and log-only events carry neither metadata field.
+
+`maxBytes` bounds the complete serialized field in UTF-8 bytes, including the header and numeric envelope fields. A backlog above the limit drains across consecutive accepted requests, each continuing after the previous `throughSeq`. When the first pending event alone exceeds the limit, the request omits `dsh_session_log`, the plugin logs a warning, and the watermark stays before that event until `maxBytes` admits it. An event too large for the runtime to serialize at all is handled the same way, and no `maxBytes` value admits it.
 
 <a id="acceptance-and-retry"></a>
 ## Acceptance and retry
 
-The DeepSeek adapter calls the prepared contribution's `accept()` after HTTP 2xx, before it consumes the SSE body. Acceptance appends `session-log-deepseek/delivery-accepted` with the uploaded `throughSeq` and `sessionFormatVersion`; a record that omits the format field denotes v0. The next request uploads that event as part of its new suffix. Transport and non-2xx failures append no acceptance record, so later requests resend the uncertain range. Concurrent deliveries may be accepted out of order; folding the maximum matching `throughSeq` prevents cursor regression.
+The DeepSeek adapter calls the prepared contribution's `accept()` after HTTP 2xx, before it consumes the SSE body. Acceptance appends `session-log-deepseek/delivery-accepted` with the uploaded `throughSeq` and `sessionFormatVersion`; a record that omits the format field denotes v0. The next request uploads that event as part of its new suffix. Transport failures, non-2xx failures, and requests that the DeepSeek adapter sends without extension fields after they fail to serialize append no acceptance record, so later requests resend the uncertain range. Concurrent deliveries may be accepted out of order; folding the maximum matching `throughSeq` prevents cursor regression.
 
 A crash after server acceptance but before the watermark reaches persistence can replay an accepted range after restart. This is the at-least-once failure direction: uncertainty creates duplicates, never a skipped sequence. The ordinary session checkpoint policy persists the watermark at the next semantic checkpoint; this plugin performs no independent I/O.
 
@@ -56,7 +59,7 @@ Nothing. `dsh_session_log` is a sibling of the DeepSeek request's model-input fi
 
 #### Token effect
 
-Zero model-input tokens; the field only increases HTTP request bytes.
+Zero model-input tokens; the field only increases HTTP request bytes, bounded by `maxBytes`.
 
 #### KV Cache effect
 
@@ -68,7 +71,8 @@ None; the model-visible request prefix remains unchanged.
 
 - **Crash-window duplicates** — a 2xx followed by process loss before the acceptance watermark persists causes conservative replay on resume.
 - **No live Session means no field** — direct or stale-session calls have no canonical log to snapshot; explicit absence semantics remain deferred.
-- **No independent request-size cap** — complete delivery is fail-closed; provider rejection leaves the cursor unchanged instead of truncating the log.
+- **An oversized event stalls upload** — an event whose field alone exceeds `maxBytes` is not sent, and later events wait behind it until the limit increases; an event too large to serialize at all stays blocked.
+- **Provider rejection fails the request** — a provider that rejects the request because of this field fails the model request and leaves the cursor unchanged instead of truncating the log.
 
 <a id="dev-note"></a>
 ### Dev Note

package/README.zh.md

@@ -28,18 +28,21 @@ kind: "package-reference"
 | 配置键 | 默认值 | 含义 |
 |---|---:|---|
 | `enabled` | `true` | 注册 `dsh_session_log` 贡献。将其设为 `false` 可停止会话日志上传。 |
+| `maxBytes` | 8 MiB | 单次请求携带的 `dsh_session_log` 字段序列化后的最大 UTF-8 字节数。 |
 
 随附 profile 会挂载该插件，因此默认配置会注册请求字段并追加接受水位；overlay 可用 `enabled: false` 选择退出。
 
 <a id="request-field"></a>
 ## 请求字段
 
-对于携带存活 `sessionId` 的请求，插件会折叠该确切会话格式代的最大已接受水位，对 `Session.events` 取快照，并发送水位之后的连续后缀。进程内 fold 会让每条事件只被扫描一次并增量消费后续追加；重启与 HMR（热模块替换）会从持久日志重建它。版本 1 字段包含 `sessionFormatVersion`、原始会话 header（仅 seeded Session 携带 `seedLength`）、数值型 `afterSeq` 与 `throughSeq`，以及每个已转换为原始数值 envelope 字段的完整规范事件。只有记录的会话 id 与格式代均匹配请求来源时水位才生效，因此 fork 会话会忽略从父会话继承的水位。表层事件必须携带 `surfaceOp`，替换范围使用数值型 `startSeq` 与 `endSeq`；仅 system、user 与 tool 事件可以携带 `sourceEventSeqs`。assistant 的提供方元数据保留在内嵌流中，只出现在日志中的事件不携带这两个元数据字段。
+对于携带存活 `sessionId` 的请求，插件会折叠该确切会话格式代的最大已接受水位，对 `Session.events` 取快照，并发送水位之后能放进 `maxBytes` 的最长连续事件段。进程内 fold 会让每条事件只被扫描一次并增量消费后续追加；重启与 HMR（热模块替换）会从持久日志重建它。版本 1 字段包含 `sessionFormatVersion`、原始会话 header（仅 seeded Session 携带 `seedLength`）、数值型 `afterSeq` 与 `throughSeq`，以及每个已转换为原始数值 envelope 字段的完整规范事件。只有记录的会话 id 与格式代均匹配请求来源时水位才生效，因此 fork 会话会忽略从父会话继承的水位。表层事件必须携带 `surfaceOp`，替换范围使用数值型 `startSeq` 与 `endSeq`；仅 system、user 与 tool 事件可以携带 `sourceEventSeqs`。assistant 的提供方元数据保留在内嵌流中，只出现在日志中的事件不携带这两个元数据字段。
+
+`maxBytes` 按 UTF-8 字节限制完整的序列化字段，包括 header 与数值型 envelope 字段。超过上限的积压会分多次已接受的请求补传，每次都从上一次的 `throughSeq` 之后继续。第一条待发事件本身就超过上限时，请求会省略 `dsh_session_log`，插件记录一条告警，水位停在该事件之前，直到 `maxBytes` 能容纳它。运行时根本无法序列化的超大事件也按同样方式处理，且任何 `maxBytes` 都无法容纳它。
 
 <a id="acceptance-and-retry"></a>
 ## 接受与重试
 
-DeepSeek 适配器会在 HTTP 2xx 后、消费 SSE（Server-Sent Events）正文前调用已准备贡献的 `accept()`。接受操作会追加 `session-log-deepseek/delivery-accepted`，其中包含已上传的 `throughSeq` 与 `sessionFormatVersion`；省略格式字段的记录表示 v0。下一次请求再把该事件作为新后缀的一部分上传。传输失败与非 2xx 失败不会追加接受记录，因此后续请求会重发不确定范围。并发交付可能乱序得到接受；折叠匹配记录中最大的 `throughSeq` 可以防止游标回退。
+DeepSeek 适配器会在 HTTP 2xx 后、消费 SSE（Server-Sent Events）正文前调用已准备贡献的 `accept()`。接受操作会追加 `session-log-deepseek/delivery-accepted`，其中包含已上传的 `throughSeq` 与 `sessionFormatVersion`；省略格式字段的记录表示 v0。下一次请求再把该事件作为新后缀的一部分上传。传输失败、非 2xx 失败，以及 DeepSeek 适配器在扩展字段序列化失败后不带扩展字段发出的请求，都不会追加接受记录，因此后续请求会重发不确定范围。并发交付可能乱序得到接受；折叠匹配记录中最大的 `throughSeq` 可以防止游标回退。
 
 服务端接受后、持久化水位前发生崩溃，可能让恢复后的进程重放已经接受的范围。这是至少一次交付的失败方向：不确定性会制造重复，绝不会跳过序列。普通会话检查点策略会在下一个语义检查点持久化水位；本插件不执行独立 I/O。
 
@@ -56,7 +59,7 @@ DeepSeek 适配器会在 HTTP 2xx 后、消费 SSE（Server-Sent Events）正文
 
 #### Token 影响
 
-模型输入 token 为零；该字段只会增加 HTTP 请求字节数。
+模型输入 token 为零；该字段只会增加 HTTP 请求字节数，且受 `maxBytes` 限制。
 
 #### KV Cache 影响
 
@@ -68,7 +71,8 @@ DeepSeek 适配器会在 HTTP 2xx 后、消费 SSE（Server-Sent Events）正文
 
 - **崩溃窗口重复**——2xx 后、接受水位持久化前进程终止，会在恢复时触发保守重放。
 - **缺少存活会话就没有字段**——直接调用或陈旧会话调用没有可供快照的规范日志；显式缺失语义仍暂缓处理。
-- **没有独立请求大小上限**——完整交付采用 fail-closed 策略；提供方拒绝会保持游标不变，而非截断日志。
+- **超限事件会让上传停住**——字段单独就超过 `maxBytes` 的事件不会发送，后续事件也排在它后面，直到上限调高；根本无法序列化的事件会一直阻塞上传。
+- **提供方拒绝会让请求失败**——提供方因该字段拒绝请求时，模型请求失败，游标保持不变，而非截断日志。
 
 <a id="dev-note"></a>
 ### 开发备注

package/lib/index.js

@@ -1,3 +1,4 @@
+import { Buffer } from "node:buffer";
 import z from "@deepseek-ai/schemastery";
 import { brandString } from "@deepseek-ai/dsh-brand";
 import { KNOWN_SESSION_EVENT_TYPES, SessionLogOffset, SessionSeq } from "@deepseek-ai/dsh-session";
@@ -13,7 +14,10 @@ const name = "session-log-deepseek";
 /** Services required to resolve sessions and contribute the provider request field. */
 const inject = ["deepseekLlmApiExtensions", "sessions"];
 /** Validated Session-log request contribution configuration. */
-const Config = z.object({ enabled: z.boolean().default(true) });
+const Config = z.object({
+	enabled: z.boolean().default(true),
+	maxBytes: z.number().step(1).min(1).default(8 * 1024 * 1024)
+});
 const acceptanceFolds = /* @__PURE__ */ new WeakMap();
 /** Translate logical Session metadata to raw external request fields. */
 function wireHeader(session) {
@@ -78,6 +82,19 @@ function wireSurfaceOp(op) {
 	};
 }
 /**
+* UTF-8 length of one value's JSON text as the request body encodes it.
+* @returns `Infinity` when the value fails to serialize, which counts as exceeding every limit.
+*/
+function jsonBytes(value) {
+	let text;
+	try {
+		text = JSON.stringify(value);
+	} catch (_unserializable) {
+		return Number.POSITIVE_INFINITY;
+	}
+	return Buffer.byteLength(text);
+}
+/**
 * Highest confirmed sequence for this exact Session format generation.
 * @param session - canonical log whose matching acceptance events are folded.
 * @returns greatest accepted sequence, or `-1` before any accepted request.
@@ -117,22 +134,49 @@ function acceptedThrough(session) {
 */
 function apply(ctx, config) {
 	if (config.enabled !== true) return;
+	const { maxBytes } = config;
 	ctx.deepseekLlmApiExtensions.register("dsh_session_log", { prepare: (request) => {
 		if (request.sessionId === void 0) return void 0;
 		const session = ctx.sessions.get(brandString(request.sessionId));
 		if (session === void 0) return void 0;
 		const afterSeq = acceptedThrough(session);
-		const throughSeq = session.snapshotEvents().at(-1)?.seq;
-		if (throughSeq === void 0) return void 0;
-		const suffix = session.snapshotEvents(SessionLogOffset(afterSeq + 1));
+		const pending = session.snapshotEvents(SessionLogOffset(afterSeq + 1));
+		const envelope = {
+			version: 1,
+			sessionFormatVersion: session.header.version,
+			session: wireHeader(session),
+			afterSeq: Number(afterSeq)
+		};
+		let bytes = jsonBytes({
+			...envelope,
+			throughSeq: 0,
+			events: []
+		}) - 1;
+		const events = [];
+		let candidateBytes = 0;
+		for (const event of pending) {
+			const wire = wireEvent(event);
+			const next = bytes + (events.length === 0 ? 0 : 1) + jsonBytes(wire);
+			candidateBytes = next + String(event.seq).length;
+			if (candidateBytes > maxBytes) break;
+			bytes = next;
+			events.push(wire);
+		}
+		const last = events.length === 0 ? void 0 : pending[events.length - 1];
+		if (last === void 0) {
+			const first = pending[0];
+			if (first !== void 0) {
+				const seq = String(first.seq);
+				ctx.logger.warn(Number.isFinite(candidateBytes) ? `session-log-deepseek: event ${seq} of session "${session.id}" needs a ${String(candidateBytes)}-byte dsh_session_log field, above maxBytes ${String(maxBytes)}; this session's upload stays at event ${seq} until maxBytes admits it` : `session-log-deepseek: event ${seq} of session "${session.id}" is too large to serialize into a dsh_session_log field; this session's upload stays at event ${seq}`);
+			}
+			return;
+		}
+		const throughSeq = last.seq;
 		return {
 			value: {
-				version: 1,
-				sessionFormatVersion: session.header.version,
-				session: wireHeader(session),
-				afterSeq: Number(afterSeq),
+				...envelope,
 				throughSeq: Number(throughSeq),
-				events: suffix.map(wireEvent)
+				events
 			},
 			accept: () => {
 				session.append("session-log-deepseek/delivery-accepted", {

package/lib/types/index.d.ts

@@ -16,6 +16,12 @@ export declare const inject: string[];
 export interface Config {
     /** Contribute `dsh_session_log` to official DeepSeek requests. Defaults to `true`. */
     enabled?: boolean;
+    /**
+     * Largest serialized `dsh_session_log` field, in UTF-8 bytes, that one request carries.
+     * A request uploads the longest pending event prefix that fits; later requests continue
+     * after its acceptance. Defaults to 8 MiB.
+     */
+    maxBytes?: number;
 }
 /** Validated Session-log request contribution configuration. */
 export declare const Config: z<Config>;

package/lib/types/index.js

@@ -4,6 +4,7 @@
  * can conservatively resend uncertain tails without maintaining another store.
  * @module @deepseek-ai/dsh-session-log-deepseek
  */
+import { Buffer } from 'node:buffer';
 import z from '@deepseek-ai/schemastery';
 import { brandString } from '@deepseek-ai/dsh-brand';
 import { KNOWN_SESSION_EVENT_TYPES, SessionLogOffset, SessionSeq } from '@deepseek-ai/dsh-session';
@@ -14,6 +15,7 @@ export const inject = ['deepseekLlmApiExtensions', 'sessions'];
 /** Validated Session-log request contribution configuration. */
 export const Config = z.object({
     enabled: z.boolean().default(true),
+    maxBytes: z.number().step(1).min(1).default(8 * 1024 * 1024),
 });
 const acceptanceFolds = new WeakMap();
 /** Translate logical Session metadata to raw external request fields. */
@@ -71,6 +73,21 @@ function wireSurfaceOp(op) {
         ? op
         : { op: 'replace', startSeq: Number(op.startSeq), endSeq: Number(op.endSeq) };
 }
+/**
+ * UTF-8 length of one value's JSON text as the request body encodes it.
+ * @returns `Infinity` when the value fails to serialize, which counts as exceeding every limit.
+ */
+function jsonBytes(value) {
+    let text;
+    try {
+        text = JSON.stringify(value);
+    }
+    catch (_unserializable) {
+        // No request can carry a value that fails to serialize.
+        return Number.POSITIVE_INFINITY;
+    }
+    return Buffer.byteLength(text);
+}
 /**
  * Highest confirmed sequence for this exact Session format generation.
  * @param session - canonical log whose matching acceptance events are folded.
@@ -124,6 +141,8 @@ export function acceptedThrough(session) {
 export function apply(ctx, config) {
     if (config.enabled !== true)
         return;
+    // Schemastery validates and fills the defaults before `apply` runs.
+    const { maxBytes } = config;
     ctx.deepseekLlmApiExtensions.register('dsh_session_log', {
         prepare: (request) => {
             // TODO: Define an explicit wire result for direct or stale-session calls if they become a supported product path.
@@ -134,20 +153,43 @@ export function apply(ctx, config) {
                 return undefined;
             const afterSeq = acceptedThrough(session);
             // oxlint-disable-next-line typescript/no-deprecated -- Existing Session history read; migration deferred.
-            const snapshot = session.snapshotEvents();
-            const throughSeq = snapshot.at(-1)?.seq;
-            if (throughSeq === undefined)
-                return undefined;
-            // oxlint-disable-next-line typescript/no-deprecated -- Existing Session history read; migration deferred.
-            const suffix = session.snapshotEvents(SessionLogOffset(afterSeq + 1));
-            const value = {
+            const pending = session.snapshotEvents(SessionLogOffset(afterSeq + 1));
+            const envelope = {
                 version: 1,
                 sessionFormatVersion: session.header.version,
                 session: wireHeader(session),
                 afterSeq: Number(afterSeq),
-                throughSeq: Number(throughSeq),
-                events: suffix.map(wireEvent),
             };
+            // Field bytes without events or throughSeq digits; each candidate prefix adds its own.
+            let bytes = jsonBytes({ ...envelope, throughSeq: 0, events: [] }) - 1;
+            const events = [];
+            // Field bytes with the last examined event; when none fits, the first event's own field size.
+            let candidateBytes = 0;
+            for (const event of pending) {
+                const wire = wireEvent(event);
+                const next = bytes + (events.length === 0 ? 0 : 1) + jsonBytes(wire);
+                candidateBytes = next + String(event.seq).length;
+                if (candidateBytes > maxBytes)
+                    break;
+                bytes = next;
+                events.push(wire);
+            }
+            const last = events.length === 0 ? undefined : pending[events.length - 1];
+            if (last === undefined) {
+                const first = pending[0];
+                if (first !== undefined) {
+                    const seq = String(first.seq);
+                    ctx.logger.warn(Number.isFinite(candidateBytes)
+                        ? `session-log-deepseek: event ${seq} of session "${session.id}" needs a ${String(candidateBytes)}-byte`
+                            + ` dsh_session_log field, above maxBytes ${String(maxBytes)}; this session's upload stays at event ${seq}`
+                            + ' until maxBytes admits it'
+                        : `session-log-deepseek: event ${seq} of session "${session.id}" is too large to serialize into a dsh_session_log field;`
+                            + ` this session's upload stays at event ${seq}`);
+                }
+                return undefined;
+            }
+            const throughSeq = last.seq;
+            const value = { ...envelope, throughSeq: Number(throughSeq), events };
             return {
                 value,
                 accept: () => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-session-log-deepseek",
   "description": "Incremental lossless session-log request extension for the official DeepSeek LLM API",
-  "version": "0.1.7-alpha.2",
+  "version": "0.1.7-rc.2",
   "publishConfig": {
     "access": "public"
   },
@@ -37,28 +37,29 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@deepseek-ai/dsh-brand": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-util-values": "0.1.7-alpha.2",
+    "@deepseek-ai/dsh-brand": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-util-values": "0.1.7-rc.2",
     "@deepseek-ai/schemastery": "~3.18.4"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-deepseek-llm-api-extensions": "0.1.7-alpha.2",
     "@deepseek-ai/cordis": "~4.0.4",
-    "@deepseek-ai/dsh-invariants": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-session": "0.1.7-alpha.2"
+    "@deepseek-ai/dsh-deepseek-llm-api-extensions": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-invariants": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-session": "0.1.7-rc.2"
   },
   "devDependencies": {
+    "@deepseek-ai/cordis": "~4.0.4",
     "@deepseek-ai/cordis-plugin-include": "~1.0.9",
     "@deepseek-ai/cordis-plugin-loader": "~1.0.5",
-    "@deepseek-ai/dsh-command-feedback": "0.1.7-alpha.2",
-    "@deepseek-ai/cordis": "~4.0.4",
-    "@deepseek-ai/dsh-deepseek-llm-api-extensions": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-invariants": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-llm": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-llm-deepseek": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-llm-mock-server": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-message-feedback": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-session": "0.1.7-alpha.2",
-    "@deepseek-ai/dsh-session-persistence-jsonl": "0.1.7-alpha.2"
+    "@deepseek-ai/dsh-command-feedback": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-deepseek-llm-api-extensions": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-invariants": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-llm": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-llm-deepseek": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-llm-deepseek-api-key": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-message-feedback": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-session-persistence-jsonl": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-session": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-llm-mock-server": "0.1.7-rc.2"
   }
 }