@deepseek-ai/dsh-llm 0.1.0-rc.6 → 0.1.0-rc.7

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # 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/llm/llm/README.md
-README.md: 2cae9a05a58295b06d25382729a3304dbdc9a6fa
-README.zh.md: 110cc128f1c19bef1741ae59d8106139c4a72649
+README.md: fb6bd84240b41dd730d45b3eb34c35827dc4c991
+README.zh.md: 5c22767a7c654972cbf614505382fa4755d7d318

package/README.md

@@ -53,7 +53,7 @@ Exact-model metadata is a separate correctness query, not a catalog decoration o
 
 Message content is an array of typed blocks: `text`, `reasoning`, `tool-call`, `tool-result`. The union is derived from the merge-extensible `ContentBlockMap`, so plugins can add block types via declaration merging. Assistant messages use a model source carrying the provider and model that produced them plus optional adapter-private replay state. Before dispatch, `LlmRuntime` retains that state only when the historical provider route and target provider route are currently owned by the exact same adapter instance; the adapter then decides whether it can restore or convert the state across models/providers. The core block set is limited to blocks every shipping path honors — multimodal content (images, audio, …) has no core block type; a feature that needs one adds it via the map together with the adapter/UI/compaction support that honors it.
 
-Streaming is a raw chunk protocol (`block-start`, `text-delta`, `reasoning-delta`, `tool-call-delta`, `block-end`, `usage`, `finish`). Every adapter outcome reaches consumers as one terminal `finish`; operational failure uses its `error` or `aborted` reason rather than throwing across the stream API. `BlockAssembler` is the single shared implementation that assembles chunks into blocks/messages.
+Streaming is a raw chunk protocol (`block-start`, `text-delta`, `reasoning-delta`, `tool-call-delta`, `block-end`, `usage`, `finish`). Every adapter outcome reaches consumers as one terminal `finish`; operational failure uses its `error` or `aborted` reason rather than throwing across the stream API. `BlockAssembler` is the single shared implementation that assembles chunks into blocks/messages. A successful `finish` may carry a `ReplayEnvelope` — opaque response-level replay metadata plus optional per-block entries aligned with the emitted block sequence. Assembly makes one keep/drop decision for content and metadata together: a `max-tokens` finish drops tool calls that may have been truncated, and the envelope loses the entry at each dropped position, so stored metadata always describes stored content.
 
 ### Call configuration (`call-config.ts`)
 

package/README.zh.md

@@ -53,7 +53,7 @@
 
 消息内容是类型化内容块数组：`text`、`reasoning`、`tool-call`、`tool-result`。联合从可合并扩展的 `ContentBlockMap` 派生，因此插件可以通过 declaration merging 添加块类型。assistant 消息使用模型来源，其中携带生成该消息的提供方和模型，以及可选的适配器私有回放状态。dispatch 前，`LlmRuntime` 只在历史提供方路由与目标提供方路由当前由完全相同的适配器实例拥有时才保留该状态；随后由适配器判定能否在模型／提供方间恢复或转换该状态。核心块集只包含每条已发布路径都支持的块。多模态内容（图像、音频等）没有核心块类型；需要它的功能会通过 map 添加，并一并添加相应的适配器／UI／压缩（compaction）支持。
 
-流式输出是原始分片协议（`block-start`、`text-delta`、`reasoning-delta`、`tool-call-delta`、`block-end`、`usage`、`finish`）。每个适配器结果都以一个终止 `finish` 到达消费方；运行故障使用 `error` 或 `aborted` 作为结束原因，而不会跨流 API 抛出。`BlockAssembler` 是将分片组装为块／消息的唯一共享实现。
+流式输出是原始分片协议（`block-start`、`text-delta`、`reasoning-delta`、`tool-call-delta`、`block-end`、`usage`、`finish`）。每个适配器结果都以一个终止 `finish` 到达消费方；运行故障使用 `error` 或 `aborted` 作为结束原因，而不会跨流 API 抛出。`BlockAssembler` 是将分片组装为块／消息的唯一共享实现。成功的 `finish` 可以携带 `ReplayEnvelope`——不透明的响应级回放元数据，加上与发射块序列对齐的可选逐块条目。组装对内容与元数据只做一次保留/丢弃决定：`max-tokens` 结束会丢弃可能被截断的工具调用，数据在每个被丢弃的位置同步失去对应条目，因此存储的元数据始终描述存储的内容。
 
 ### 调用配置（`call-config.ts`）
 

package/lib/index.js

@@ -675,7 +675,7 @@ var BlockAssembler = class {
 	order = [];
 	_usage;
 	_finish;
-	_replayState = void 0;
+	_replayState;
 	/**
 	* Feed one chunk into the assembly state.
 	* @param chunk - the next raw chunk, in stream order.
@@ -763,14 +763,39 @@ var BlockAssembler = class {
 		return partial;
 	}
 	/**
+	* The one shared keep/drop decision over all seen blocks: max-token
+	* truncation drops tool calls that cannot be executed safely. Emitted blocks
+	* and replay metadata both derive from this result, so they cannot disagree.
+	*/
+	assembled() {
+		const all = this.order.map((index) => this.assemble(this.mustGet(index), index));
+		const kept = this.finish.kind === "max-tokens" ? all.map((block) => block.type !== "tool-call") : void 0;
+		const blocks = kept === void 0 ? all : all.filter((_, position) => kept[position]);
+		const envelope = this._replayState;
+		if (envelope?.blocks === void 0) return {
+			blocks,
+			replay: envelope
+		};
+		if (envelope.blocks.length !== all.length) return {
+			blocks,
+			replay: void 0
+		};
+		return {
+			blocks,
+			replay: kept === void 0 || blocks.length === all.length ? envelope : {
+				response: envelope.response,
+				blocks: envelope.blocks.filter((_, position) => kept[position])
+			}
+		};
+	}
+	/**
 	* Assemble all blocks seen so far, in stream order.
 	* @returns one block per seen index, except that max-token truncation drops
 	*   tool calls that cannot be executed safely; an open block assembles from
 	*   its accumulated deltas (an unknown block type never closed by `block-end` throws).
 	*/
 	blocks() {
-		const blocks = this.order.map((index) => this.assemble(this.mustGet(index), index));
-		return this.finish.kind === "max-tokens" ? blocks.filter((block) => block.type !== "tool-call") : blocks;
+		return this.assembled().blocks;
 	}
 	/** Usage from the `usage` chunk; undefined until one arrives. */
 	get usage() {
@@ -780,9 +805,13 @@ var BlockAssembler = class {
 	get finish() {
 		return this._finish ?? { kind: "stop" };
 	}
-	/** Adapter-private replay state from the terminal finish chunk, if any. */
+	/**
+	* Replay metadata from the terminal finish chunk, if any, with per-block
+	* entries pruned in step with {@link blocks}. Undefined when the envelope's
+	* entries do not align with the emitted blocks.
+	*/
 	get replayState() {
-		return this._replayState;
+		return this.assembled().replay;
 	}
 	/**
 	* The assembled assistant message.

package/lib/types/assembler.d.ts

@@ -6,7 +6,7 @@
  * @module @deepseek-ai/dsh-llm/assembler
  */
 import type { Message, MessageSource } from './message.ts';
-import type { ContentBlock, FinishReason, StreamChunk, TokenUsage } from './types.ts';
+import type { ContentBlock, FinishReason, ReplayEnvelope, StreamChunk, TokenUsage } from './types.ts';
 /**
  * Incrementally assembles raw {@link StreamChunk}s into complete
  * {@link ContentBlock}s and a final assistant {@link Message}.
@@ -33,6 +33,12 @@ export declare class BlockAssembler {
     private assemble;
     /** Invariant accessor: every index in `order` has a partial. */
     private mustGet;
+    /**
+     * The one shared keep/drop decision over all seen blocks: max-token
+     * truncation drops tool calls that cannot be executed safely. Emitted blocks
+     * and replay metadata both derive from this result, so they cannot disagree.
+     */
+    private assembled;
     /**
      * Assemble all blocks seen so far, in stream order.
      * @returns one block per seen index, except that max-token truncation drops
@@ -44,8 +50,12 @@ export declare class BlockAssembler {
     get usage(): TokenUsage | undefined;
     /** Finish reason from the `finish` chunk; `{kind: 'stop'}` when the stream ended without one. */
     get finish(): FinishReason;
-    /** Adapter-private replay state from the terminal finish chunk, if any. */
-    get replayState(): unknown;
+    /**
+     * Replay metadata from the terminal finish chunk, if any, with per-block
+     * entries pruned in step with {@link blocks}. Undefined when the envelope's
+     * entries do not align with the emitted blocks.
+     */
+    get replayState(): ReplayEnvelope | undefined;
     /**
      * The assembled assistant message.
      * @param source - producer attribution for the assembled message.

package/lib/types/assembler.js

@@ -24,7 +24,7 @@ export class BlockAssembler {
     order = [];
     _usage;
     _finish;
-    _replayState = undefined;
+    _replayState;
     /**
      * Feed one chunk into the assembly state.
      * @param chunk - the next raw chunk, in stream order.
@@ -112,6 +112,29 @@ export class BlockAssembler {
             throw new Error(`BlockAssembler invariant violated: no partial for index ${index}`);
         return partial;
     }
+    /**
+     * The one shared keep/drop decision over all seen blocks: max-token
+     * truncation drops tool calls that cannot be executed safely. Emitted blocks
+     * and replay metadata both derive from this result, so they cannot disagree.
+     */
+    assembled() {
+        const all = this.order.map(index => this.assemble(this.mustGet(index), index));
+        const kept = this.finish.kind === 'max-tokens'
+            ? all.map(block => block.type !== 'tool-call')
+            : undefined;
+        const blocks = kept === undefined ? all : all.filter((_, position) => kept[position]);
+        const envelope = this._replayState;
+        if (envelope?.blocks === undefined)
+            return { blocks, replay: envelope };
+        if (envelope.blocks.length !== all.length)
+            return { blocks, replay: undefined };
+        return {
+            blocks,
+            replay: kept === undefined || blocks.length === all.length
+                ? envelope
+                : { response: envelope.response, blocks: envelope.blocks.filter((_, position) => kept[position]) },
+        };
+    }
     /**
      * Assemble all blocks seen so far, in stream order.
      * @returns one block per seen index, except that max-token truncation drops
@@ -119,10 +142,7 @@ export class BlockAssembler {
      *   its accumulated deltas (an unknown block type never closed by `block-end` throws).
      */
     blocks() {
-        const blocks = this.order.map(index => this.assemble(this.mustGet(index), index));
-        return this.finish.kind === 'max-tokens'
-            ? blocks.filter(block => block.type !== 'tool-call')
-            : blocks;
+        return this.assembled().blocks;
     }
     /** Usage from the `usage` chunk; undefined until one arrives. */
     get usage() {
@@ -132,9 +152,13 @@ export class BlockAssembler {
     get finish() {
         return this._finish ?? { kind: 'stop' };
     }
-    /** Adapter-private replay state from the terminal finish chunk, if any. */
+    /**
+     * Replay metadata from the terminal finish chunk, if any, with per-block
+     * entries pruned in step with {@link blocks}. Undefined when the envelope's
+     * entries do not align with the emitted blocks.
+     */
     get replayState() {
-        return this._replayState;
+        return this.assembled().replay;
     }
     /**
      * The assembled assistant message.

package/lib/types/types.d.ts

@@ -256,6 +256,26 @@ export interface LlmResolvedModelInfo extends LlmModelInfo {
     /** Adapter-owned selectable reasoning levels when exposed. */
     reasoning?: LlmModelReasoningInfo;
 }
+/**
+ * Adapter-private lossless-JSON state for replaying a successful response,
+ * carried by a terminal `finish` chunk and stored on the assembled assistant
+ * message's model source. Both halves stay opaque to the harness; only the
+ * split is shared vocabulary, so assembly can keep stored metadata aligned
+ * with stored content without reading either half.
+ */
+export interface ReplayEnvelope {
+    /** Response-level adapter-private metadata (ids, native stop reason). */
+    response: unknown;
+    /**
+     * Per-block adapter-private metadata, one entry per emitted block in
+     * first-seen stream order. When assembly drops a block it drops the entry at
+     * the same position; entries whose length does not match the emitted block
+     * count discard the whole envelope. An adapter whose metadata is independent
+     * of block structure omits this field and the envelope passes through
+     * assembly unchanged.
+     */
+    blocks?: readonly unknown[];
+}
 /**
  * Raw streaming protocol emitted by adapters.
  * Block indexes correlate interleaved deltas, and `block-end` carries the
@@ -292,8 +312,8 @@ export type StreamChunk = {
 } | {
     type: 'finish';
     reason: FinishReason;
-    /** Adapter-private lossless-JSON state for replaying a successful response. */
-    replayState?: unknown;
+    /** Replay metadata for a successful response; see {@link ReplayEnvelope}. */
+    replayState?: ReplayEnvelope;
 };
 /**
  * JSON-schema description of a tool, as sent to the model.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-llm",
   "description": "Provider-neutral LLM service interface for the DeepSeek Harness",
-  "version": "0.1.0-rc.6",
+  "version": "0.1.0-rc.7",
   "publishConfig": {
     "access": "public"
   },
@@ -45,20 +45,20 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/dsh-attachment": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-brand": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-timeout": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-attachment": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-brand": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-timeout": "^0.1.0-rc.7",
     "@deepseek-ai/cordis": "^4.0.1"
   },
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-attachment": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-brand": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.6",
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-timeout": "^0.1.0-rc.6"
+    "@deepseek-ai/dsh-attachment": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-brand": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-timeout": "^0.1.0-rc.7",
+    "@deepseek-ai/cordis": "^4.0.1"
   }
 }