@deepseek-ai/dsh-session-log-deepseek 0.1.2-alpha.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.i18n.yaml

@@ -0,0 +1,6 @@
+# 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:
+#   pnpm run verify-translation-pairing --write packages/session/session-log-deepseek/README.md
+README.md: e76a4ba7d48deafb13f5dfcc1e7ea6532a4452d7
+README.zh.md: f2bf91418430fee960350fa0feb6053704dad543

package/README.md

@@ -0,0 +1,82 @@
+---
+description: "Incremental canonical session-log upload for deployments enabling official DeepSeek request metadata."
+kind: "package-reference"
+---
+
+# @deepseek-ai/dsh-session-log-deepseek
+
+English | [中文](README.zh.md)
+
+## Summary
+
+Incremental canonical session-log upload for official DeepSeek LLM API requests. This function plugin injects `ctx.sessions` and `ctx.deepseekLlmApiExtensions`, then owns the `dsh_session_log` request field and the durable `session-log-deepseek/delivery-accepted` event from which it derives the acceptance watermark. Enable it only when the official API should receive a Session-log suffix.
+
+## Table of Contents
+
+- [Configuration](#configuration)
+- [Request field](#request-field)
+- [Acceptance and retry](#acceptance-and-retry)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="configuration"></a>
+## Configuration
+
+| Key | Default | Meaning |
+|---|---:|---|
+| `enabled` | `false` | Register the `dsh_session_log` contribution. Set it to `true` to opt into Session-log upload. |
+
+Shipped profiles mount the plugin so an overlay can enable it, but the default configuration registers no request field and appends no acceptance watermark.
+
+<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 identity, 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 the immutable `SessionHeader`, `afterSeq`, `throughSeq`, and every complete canonical `SessionEvent` in that range as a direct array element. Forked sessions ignore inherited parent watermarks because each watermark records the Session id sent on the accepted request.
+
+<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`; 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.
+
+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.
+
+Direct requests without a live Session omit `dsh_session_log`. Normal agent, compaction, and session-title calls carry their live Session id.
+
+<a id="model-experience"></a>
+## Model Experience
+
+### Session-log metadata
+
+#### What the model sees
+
+Nothing. `dsh_session_log` is a sibling of the DeepSeek request's model-input fields and is not inserted into `messages`, the system prompt, or tool schemas.
+
+#### Token effect
+
+Zero model-input tokens; the field only increases HTTP request bytes.
+
+#### KV Cache effect
+
+None; the model-visible request prefix remains unchanged.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- **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.
+
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>

package/README.zh.md

@@ -0,0 +1,82 @@
+---
+description: "面向启用官方 DeepSeek 请求元数据的部署，说明规范会话日志的增量上传。"
+kind: "package-reference"
+---
+
+# @deepseek-ai/dsh-session-log-deepseek
+
+[English](README.md) | 中文
+
+## 概述
+
+用于 DeepSeek 官方 LLM API 请求的增量权威会话日志上传。该函数插件注入 `ctx.sessions` 与 `ctx.deepseekLlmApiExtensions`，并拥有 `dsh_session_log` 请求字段以及用于派生接受水位的持久 `session-log-deepseek/delivery-accepted` 事件。仅当官方 API 需要接收 Session 日志后缀时才启用它。
+
+## 目录
+
+- [配置](#configuration)
+- [请求字段](#request-field)
+- [接受与重试](#acceptance-and-retry)
+- [模型体验](#model-experience)
+- [已知限制与暂缓事项](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="configuration"></a>
+## 配置
+
+| 配置键 | 默认值 | 含义 |
+|---|---:|---|
+| `enabled` | `false` | 注册 `dsh_session_log` 贡献。将其设为 `true` 可选择启用会话日志上传。 |
+
+随附 profile 会挂载该插件，让 overlay 可以启用它；默认配置不会注册请求字段，也不会追加接受水位。
+
+<a id="request-field"></a>
+## 请求字段
+
+对于携带存活 `sessionId` 的请求，插件会折叠该确切会话身份的最大已接受水位，对 `Session.events` 取快照，并发送水位之后的连续后缀。进程内 fold 会让每条事件只被扫描一次并增量消费后续追加；重启与 HMR 会从持久日志重建它。版本 1 字段包含不可变的 `SessionHeader`、`afterSeq`、`throughSeq`，以及作为数组直接元素的该范围内每个完整权威 `SessionEvent`。每个水位都会记录已接受请求发送的会话 id，因此 fork 会话会忽略从父会话继承的水位。
+
+<a id="acceptance-and-retry"></a>
+## 接受与重试
+
+DeepSeek 适配器会在 HTTP 2xx 后、消费 SSE（Server-Sent Events）正文前调用已准备贡献的 `accept()`。接受操作会追加 `session-log-deepseek/delivery-accepted` 及已上传的 `throughSeq`；下一次请求再把该事件作为新后缀的一部分上传。传输失败与非 2xx 失败不会追加接受记录，因此后续请求会重发不确定范围。并发交付可能乱序得到接受；折叠匹配记录中最大的 `throughSeq` 可以防止游标回退。
+
+服务端接受后、持久化水位前发生崩溃，可能让恢复后的进程重放已经接受的范围。这是至少一次交付的失败方向：不确定性会制造重复，绝不会跳过序列。普通会话检查点策略会在下一个语义检查点持久化水位；本插件不执行独立 I/O。
+
+缺少存活会话的直接请求会省略 `dsh_session_log`。普通 agent（智能体）、压缩（compaction）与会话标题调用都会携带存活会话 id。
+
+<a id="model-experience"></a>
+## 模型体验
+
+### 会话日志元数据
+
+#### 模型看到的内容
+
+无。`dsh_session_log` 是 DeepSeek 请求中模型输入字段的同级字段，不会插入 `messages`、系统提示词或工具 schema。
+
+#### Token 影响
+
+模型输入 token 为零；该字段只会增加 HTTP 请求字节数。
+
+#### KV Cache 影响
+
+无；模型可见请求前缀保持不变。
+
+## 已知限制与暂缓事项
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- **崩溃窗口重复**——2xx 后、接受水位持久化前进程丢失，会在恢复时触发保守重放。
+- **缺少存活会话就没有字段**——直接调用或陈旧会话调用没有可供快照的权威日志；显式缺失语义仍暂缓处理。
+- **没有独立请求大小上限**——完整交付会快速失败；提供方拒绝会保持游标不变，而非截断日志。
+
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者工作上下文——点击展开</summary>
+
+无。
+
+</details>

package/lib/index.js

@@ -0,0 +1,74 @@
+import z from "@deepseek-ai/schemastery";
+import { brandString } from "@deepseek-ai/dsh-brand";
+//#region lib/types/index.js
+/**
+* Incremental session-log contribution for official DeepSeek LLM API requests.
+* Accepted sequence watermarks live in the canonical log, so restart recovery
+* can conservatively resend uncertain tails without maintaining another store.
+* @module @deepseek-ai/dsh-session-log-deepseek
+*/
+/** Cordis plugin name. */
+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(false) });
+const acceptanceFolds = /* @__PURE__ */ new WeakMap();
+/**
+* Highest confirmed sequence for this exact session identity.
+* @param session - canonical log whose matching acceptance events are folded.
+* @returns greatest accepted sequence, or `-1` before any accepted request.
+*/
+function acceptedThrough(session) {
+	const previous = acceptanceFolds.get(session);
+	let throughSeq = previous?.throughSeq ?? -1;
+	const events = session.events;
+	const start = previous?.scannedEvents ?? 0;
+	for (let index = start; index < events.length; index++) {
+		const event = events[index];
+		if (event.type !== "session-log-deepseek/delivery-accepted") continue;
+		if (typeof event.data.sessionId !== "string" || event.data.sessionId.length === 0 || !Number.isSafeInteger(event.data.throughSeq) || event.data.throughSeq < 0 || event.data.throughSeq >= event.seq) throw new Error(`session-log-deepseek: malformed acceptance watermark at seq ${event.seq}`);
+		if (event.data.sessionId !== session.id) continue;
+		throughSeq = Math.max(throughSeq, event.data.throughSeq);
+	}
+	acceptanceFolds.set(session, {
+		scannedEvents: events.length,
+		throughSeq
+	});
+	return throughSeq;
+}
+/**
+* Register the incremental `dsh_session_log` request contribution when enabled.
+* @param ctx - plugin context carrying Sessions and the DeepSeek request-extension registry.
+* @param config - validated opt-in configuration.
+*/
+function apply(ctx, config) {
+	if (config.enabled !== true) return;
+	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 snapshot = session.events;
+		const throughSeq = snapshot.length - 1;
+		if (throughSeq < 0) return void 0;
+		const suffix = snapshot.slice(afterSeq + 1);
+		return {
+			value: {
+				version: 1,
+				session: session.header,
+				afterSeq,
+				throughSeq,
+				events: suffix
+			},
+			accept: () => {
+				session.append("session-log-deepseek/delivery-accepted", {
+					sessionId: session.id,
+					throughSeq
+				});
+			}
+		};
+	} });
+}
+//#endregion
+export { Config, acceptedThrough, apply, inject, name };

package/lib/invariant.js

@@ -0,0 +1,42 @@
+//#region lib/types/invariant.js
+/** Package-owned invariants for DeepSeek session-log acceptance watermarks. */
+const PACKAGE_NAME = "@deepseek-ai/dsh-session-log-deepseek";
+/** Cordis companion plugin name. */
+const name = "session-log-deepseek-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/** Validate one acceptance watermark against its containing event and session. */
+function validateDeliveryAccepted(session, event, fail) {
+	const { sessionId, throughSeq } = event.data;
+	const inherited = session.header.parentSession !== void 0 && session.header.seedLength !== void 0 && event.seq < session.header.seedLength;
+	if (sessionId !== session.id && !inherited) fail("a non-inherited session-log-deepseek/delivery-accepted event must name its containing session");
+	if (!Number.isSafeInteger(throughSeq) || throughSeq < 0 || throughSeq >= event.seq) fail(`session-log-deepseek/delivery-accepted throughSeq must identify an earlier event, got ${throughSeq} at seq ${event.seq}`);
+}
+/** Validate acceptance watermarks already present in one Session. */
+function validateSession(session, fail) {
+	for (const event of session.events) if (event.type === "session-log-deepseek/delivery-accepted") validateDeliveryAccepted(session, event, fail);
+}
+/** Validate one live session-event dispatch. */
+function validateDispatched(args, fail) {
+	const [session, event] = args;
+	if (event.type === "session-log-deepseek/delivery-accepted") validateDeliveryAccepted(session, event, fail);
+}
+/** Install validation for restored, newly created, and newly appended watermarks. */
+const install = Object.assign((ctx, fail) => {
+	const validateExisting = (session) => {
+		validateSession(session, fail);
+	};
+	ctx.sessions.list().forEach(validateExisting);
+	ctx.on("session/created", validateExisting, { global: true });
+	ctx.on("internal/dispatch", (_mode, eventName, args) => {
+		if (eventName === "session/event") validateDispatched(args, fail);
+	}, { global: true });
+}, { inject: ["sessions"] });
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Incremental session-log contribution for official DeepSeek LLM API requests.
+ * Accepted sequence watermarks live in the canonical log, so restart recovery
+ * can conservatively resend uncertain tails without maintaining another store.
+ * @module @deepseek-ai/dsh-session-log-deepseek
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { Session } from '@deepseek-ai/dsh-session';
+export type * from './types.ts';
+/** Cordis plugin name. */
+export declare const name = "session-log-deepseek";
+/** Services required to resolve sessions and contribute the provider request field. */
+export declare const inject: string[];
+/** Session-log request contribution configuration. */
+export interface Config {
+    /** Contribute `dsh_session_log` to official DeepSeek requests. Defaults to `false`. */
+    enabled?: boolean;
+}
+/** Validated Session-log request contribution configuration. */
+export declare const Config: z<Config>;
+/**
+ * Highest confirmed sequence for this exact session identity.
+ * @param session - canonical log whose matching acceptance events are folded.
+ * @returns greatest accepted sequence, or `-1` before any accepted request.
+ */
+export declare function acceptedThrough(session: Session): number;
+/**
+ * Register the incremental `dsh_session_log` request contribution when enabled.
+ * @param ctx - plugin context carrying Sessions and the DeepSeek request-extension registry.
+ * @param config - validated opt-in configuration.
+ */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -0,0 +1,83 @@
+/**
+ * Incremental session-log contribution for official DeepSeek LLM API requests.
+ * Accepted sequence watermarks live in the canonical log, so restart recovery
+ * can conservatively resend uncertain tails without maintaining another store.
+ * @module @deepseek-ai/dsh-session-log-deepseek
+ */
+import z from '@deepseek-ai/schemastery';
+import { brandString } from '@deepseek-ai/dsh-brand';
+/** Cordis plugin name. */
+export const name = 'session-log-deepseek';
+/** Services required to resolve sessions and contribute the provider request field. */
+export const inject = ['deepseekLlmApiExtensions', 'sessions'];
+/** Validated Session-log request contribution configuration. */
+export const Config = z.object({
+    enabled: z.boolean().default(false),
+});
+const acceptanceFolds = new WeakMap();
+/**
+ * Highest confirmed sequence for this exact session identity.
+ * @param session - canonical log whose matching acceptance events are folded.
+ * @returns greatest accepted sequence, or `-1` before any accepted request.
+ */
+export function acceptedThrough(session) {
+    const previous = acceptanceFolds.get(session);
+    let throughSeq = previous?.throughSeq ?? -1;
+    const events = session.events;
+    const start = previous?.scannedEvents ?? 0;
+    for (let index = start; index < events.length; index++) {
+        const event = events[index];
+        if (event.type !== 'session-log-deepseek/delivery-accepted')
+            continue;
+        if (typeof event.data.sessionId !== 'string' || event.data.sessionId.length === 0
+            || !Number.isSafeInteger(event.data.throughSeq) || event.data.throughSeq < 0
+            || event.data.throughSeq >= event.seq) {
+            throw new Error(`session-log-deepseek: malformed acceptance watermark at seq ${event.seq}`);
+        }
+        if (event.data.sessionId !== session.id)
+            continue;
+        throughSeq = Math.max(throughSeq, event.data.throughSeq);
+    }
+    acceptanceFolds.set(session, { scannedEvents: events.length, throughSeq });
+    return throughSeq;
+}
+/**
+ * Register the incremental `dsh_session_log` request contribution when enabled.
+ * @param ctx - plugin context carrying Sessions and the DeepSeek request-extension registry.
+ * @param config - validated opt-in configuration.
+ */
+export function apply(ctx, config) {
+    if (config.enabled !== true)
+        return;
+    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.
+            if (request.sessionId === undefined)
+                return undefined;
+            const session = ctx.sessions.get(brandString(request.sessionId));
+            if (session === undefined)
+                return undefined;
+            const afterSeq = acceptedThrough(session);
+            const snapshot = session.events;
+            const throughSeq = snapshot.length - 1;
+            if (throughSeq < 0)
+                return undefined;
+            const suffix = snapshot.slice(afterSeq + 1);
+            const value = {
+                version: 1,
+                session: session.header,
+                afterSeq,
+                throughSeq,
+                events: suffix,
+            };
+            return {
+                value,
+                accept: () => {
+                    session.append('session-log-deepseek/delivery-accepted', { sessionId: session.id, throughSeq });
+                    // TODO: Add an immediate lightweight checkpoint if duplicate replay after a 2xx crash window becomes unacceptable.
+                },
+            };
+        },
+    });
+}
+//# sourceMappingURL=index.js.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,13 @@
+/** Package-owned invariants for DeepSeek session-log acceptance watermarks. */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "session-log-deepseek-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/invariant.js

@@ -0,0 +1,49 @@
+/** Package-owned invariants for DeepSeek session-log acceptance watermarks. */
+const PACKAGE_NAME = '@deepseek-ai/dsh-session-log-deepseek';
+/** Cordis companion plugin name. */
+export const name = 'session-log-deepseek-invariant';
+/** Service required before the companion can reserve package ownership. */
+export const inject = ['invariants'];
+/** Validate one acceptance watermark against its containing event and session. */
+function validateDeliveryAccepted(session, event, fail) {
+    const { sessionId, throughSeq } = event.data;
+    const inherited = session.header.parentSession !== undefined
+        && session.header.seedLength !== undefined
+        && event.seq < session.header.seedLength;
+    if (sessionId !== session.id && !inherited) {
+        fail('a non-inherited session-log-deepseek/delivery-accepted event must name its containing session');
+    }
+    if (!Number.isSafeInteger(throughSeq) || throughSeq < 0 || throughSeq >= event.seq) {
+        fail(`session-log-deepseek/delivery-accepted throughSeq must identify an earlier event, got ${throughSeq} at seq ${event.seq}`);
+    }
+}
+/** Validate acceptance watermarks already present in one Session. */
+function validateSession(session, fail) {
+    for (const event of session.events) {
+        if (event.type === 'session-log-deepseek/delivery-accepted')
+            validateDeliveryAccepted(session, event, fail);
+    }
+}
+/** Validate one live session-event dispatch. */
+function validateDispatched(args, fail) {
+    const [session, event] = args;
+    if (event.type === 'session-log-deepseek/delivery-accepted')
+        validateDeliveryAccepted(session, event, fail);
+}
+/** Install validation for restored, newly created, and newly appended watermarks. */
+const install = Object.assign((ctx, fail) => {
+    const validateExisting = (session) => { validateSession(session, fail); };
+    ctx.sessions.list().forEach(validateExisting);
+    ctx.on('session/created', validateExisting, { global: true });
+    ctx.on('internal/dispatch', (_mode, eventName, args) => {
+        if (eventName === 'session/event')
+            validateDispatched(args, fail);
+    }, { global: true });
+}, { inject: ['sessions'] });
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//# sourceMappingURL=invariant.js.map

package/lib/types/types.d.ts

@@ -0,0 +1,30 @@
+/** Wire types for lossless incremental DeepSeek session-log upload. */
+import type { SessionEvent, SessionHeader } from '@deepseek-ai/dsh-session';
+/** Versioned incremental session-log field carried by an official DeepSeek request. */
+export interface DeepSeekSessionLogExtension {
+    readonly version: 1;
+    readonly session: SessionHeader;
+    /** Highest sequence durably recorded as accepted before this request, or `-1`. */
+    readonly afterSeq: number;
+    /** Highest sequence represented by {@link events}. */
+    readonly throughSeq: number;
+    /** Complete canonical event envelopes for every sequence from `afterSeq + 1` through `throughSeq`. */
+    readonly events: readonly SessionEvent[];
+}
+declare module '@deepseek-ai/dsh-deepseek-llm-api-extensions/types' {
+    interface DeepSeekLlmApiExtensionMap {
+        dsh_session_log: DeepSeekSessionLogExtension;
+    }
+}
+declare module '@deepseek-ai/dsh-session/types' {
+    interface SessionEventMap {
+        /** Records that the configured endpoint accepted one delivery through `throughSeq`. */
+        'session-log-deepseek/delivery-accepted': {
+            /** Session identity the accepted delivery carried; inherited fork markers retain the parent's id. */
+            sessionId: import('@deepseek-ai/dsh-session/types').SessionId;
+            /** Last canonical event included in the accepted request. */
+            throughSeq: number;
+        };
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,3 @@
+/** Wire types for lossless incremental DeepSeek session-log upload. */
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@deepseek-ai/dsh-session-log-deepseek",
+  "description": "Incremental lossless session-log request extension for the official DeepSeek LLM API",
+  "version": "0.1.2-alpha.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/session/session-log-deepseek"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@deepseek-ai/dsh-brand": "^0.1.2-alpha.2",
+    "@deepseek-ai/schemastery": "^3.18.2"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-deepseek-llm-api-extensions": "^0.1.2-alpha.2",
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-session": "^0.1.2-alpha.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-deepseek-llm-api-extensions": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-session": "^0.1.2-alpha.2"
+  }
+}