@khorsheed/dsh-client-message-tools 0.2.0 → 0.3.1

package/lib/types/marker.js

@@ -1,10 +1,10 @@
 /**
- * Shared message-tools markers: the plugin source tag stamped on withdrawal
- * replacement events, the `op` discriminator telling edit replacements, edit
- * triggers, and assistant-text restore replays apart from withdrawals and
- * user-message restores, the model-facing placeholder and trigger texts, and
- * the pure predicates both the Host service and the browser projection
- * consume. No new session event type is ever written — an
+ * Shared message-tools markers: the producer-owned source kind stamped on
+ * every message-tools event, the `op` discriminator telling edit
+ * replacements, edit triggers, and assistant-text restore replays apart from
+ * withdrawals and user-message restores, the model-facing placeholder and
+ * trigger texts, and the pure predicates both the Host service and the
+ * browser projection consume. No new session event type is ever written — an
  * out-of-harness event type cannot carry `ignorable: true` (Session.append
  * assigns the envelope), so a persisted unknown type would make
  * session-persistence refuse the log on reload. The events themselves are the
@@ -12,7 +12,14 @@
  * @module @khorsheed/dsh-client-message-tools/marker
  */
 import { isReplacementSurfaceEvent } from '@deepseek-ai/dsh-session/surface';
-/** Plugin source tag identifying every message-tools event. */
+/**
+ * The producer-owned source kind identifying every message-tools event. It is
+ * also the legacy wrapper's `plugin` value: released V3 logs carry
+ * `{ kind: 'plugin', plugin: 'message-tools' }` (a pre-V4 host still serves
+ * them verbatim), and the official V3→V4 migration rewrites those to
+ * `kind: 'plugin:message-tools'` — {@link isMessageToolsSource} accepts all
+ * three durable forms.
+ */
 export const MESSAGE_TOOLS_PLUGIN = 'message-tools';
 /**
  * Model-facing placeholder left on the surface in place of the withdrawn
@@ -29,28 +36,52 @@ export const WITHDRAWN_NOTICE = '(用户撤回了这条消息及其后的所有
 export const EDIT_TRIGGER_NOTICE = '(用户编辑了上一条消息，请按编辑后的内容重新回答)';
 /**
  * Model-facing frame preceding a replayed assistant text in a restore: the
- * replay lands as a user-role message (assistant/message cannot carry a
- * plugin source, and the session turn/step trace forbids ad-hoc assistant
- * appends), so the frame keeps the role honest for the model.
+ * replay lands as a user-role message (assistant/message requires the model
+ * source, and the session turn/step trace forbids ad-hoc assistant
+ * appends), so the frame keeps the role honest for the model. On hosts whose
+ * session fold carries the S12 `user/message` projection the frame never
+ * reaches the model — the projection strips it and corrects the role at
+ * derivation time; everywhere else it is the role-honesty device.
  */
 export const RESTORED_ASSISTANT_NOTICE = '(以下是先前被撤回、现随恢复放回的助手回复)';
-/** The plugin-tagged source of an edit replacement (op: 'edit'). */
+/** The producer-owned source of a withdrawal replacement or a user-message restore replay (no op). */
+export function messageToolsSource() {
+    return Object.freeze({ kind: MESSAGE_TOOLS_PLUGIN });
+}
+/** The producer-owned source of an edit replacement (op: 'edit'). */
 export function editReplacementSource() {
-    return Object.freeze({ kind: 'plugin', plugin: MESSAGE_TOOLS_PLUGIN, op: 'edit' });
+    return Object.freeze({ kind: MESSAGE_TOOLS_PLUGIN, op: 'edit' });
 }
-/** The plugin-tagged source of an edit trigger message (op: 'edit-trigger'). */
+/** The producer-owned source of an edit trigger message (op: 'edit-trigger'). */
 export function editTriggerSource() {
-    return Object.freeze({ kind: 'plugin', plugin: MESSAGE_TOOLS_PLUGIN, op: 'edit-trigger' });
+    return Object.freeze({ kind: MESSAGE_TOOLS_PLUGIN, op: 'edit-trigger' });
 }
-/** The plugin-tagged source of a restored assistant-text replay (op: 'restore-assistant'). */
+/** The producer-owned source of a restored assistant-text replay (op: 'restore-assistant'). */
 export function restoreAssistantSource() {
-    return Object.freeze({ kind: 'plugin', plugin: MESSAGE_TOOLS_PLUGIN, op: 'restore-assistant' });
+    return Object.freeze({ kind: MESSAGE_TOOLS_PLUGIN, op: 'restore-assistant' });
 }
-/** Read the op discriminator off a message source (absent on legacy events). */
+/** Read the op discriminator off a message source (absent on plain withdrawal/restore events). */
 export function messageToolsOp(source) {
     const op = source?.op;
     return op === 'edit' || op === 'edit-trigger' || op === 'restore-assistant' ? op : undefined;
 }
+/**
+ * Whether a durable source belongs to message-tools, in every form the log
+ * can hold: the current producer-owned kind (`message-tools`), the V3→V4
+ * migrated kind (`plugin:message-tools` — released V3 files rewritten once by
+ * the official migration), and the released V3 wrapper a pre-V4 host still
+ * serves verbatim (`{ kind: 'plugin', plugin: 'message-tools' }`).
+ * @param source - the persisted message source to test.
+ * @returns true when the source names this producer.
+ */
+export function isMessageToolsSource(source) {
+    if (typeof source !== 'object' || source === null)
+        return false;
+    const record = source;
+    return record.kind === MESSAGE_TOOLS_PLUGIN
+        || record.kind === `plugin:${MESSAGE_TOOLS_PLUGIN}`
+        || (record.kind === 'plugin' && record.plugin === MESSAGE_TOOLS_PLUGIN);
+}
 /**
  * Strip the model-facing restore frame from a replayed assistant text for
  * DISPLAY: the frame belongs to the model context (role honesty), never to
@@ -64,16 +95,16 @@ export function stripRestoreAssistantFrame(text) {
 }
 /**
  * Whether the event is a message-tools WITHDRAWAL replacement: a
- * `user/message` surface replacement whose source carries this plugin's tag
- * and no `op` discriminator (legacy and current withdrawals both).
+ * `user/message` surface replacement whose source names this producer
+ * (any durable form — see {@link isMessageToolsSource}) with no `op`
+ * discriminator.
  * @param event - the session event to test.
  * @returns the event narrowed to a withdrawal replacement when matched.
  */
 export function isMessageToolsReplacement(event) {
     return event.type === 'user/message'
         && isReplacementSurfaceEvent(event)
-        && event.data.source.kind === 'plugin'
-        && event.data.source.plugin === MESSAGE_TOOLS_PLUGIN
+        && isMessageToolsSource(event.data.source)
         && messageToolsOp(event.data.source) === undefined;
 }
 /**
@@ -85,8 +116,7 @@ export function isMessageToolsReplacement(event) {
 export function isMessageToolsEdit(event) {
     return event.type === 'user/message'
         && isReplacementSurfaceEvent(event)
-        && event.data.source.kind === 'plugin'
-        && event.data.source.plugin === MESSAGE_TOOLS_PLUGIN
+        && isMessageToolsSource(event.data.source)
         && messageToolsOp(event.data.source) === 'edit';
 }
 /**
@@ -98,21 +128,19 @@ export function isMessageToolsEdit(event) {
 export function isMessageToolsRestore(event) {
     return event.type === 'user/message'
         && event.surfaceOp === 'append'
-        && event.data.source.kind === 'plugin'
-        && event.data.source.plugin === MESSAGE_TOOLS_PLUGIN
+        && isMessageToolsSource(event.data.source)
         && messageToolsOp(event.data.source) === undefined;
 }
 /**
  * Whether the event is a message-tools edit trigger: the minimal
- * plugin-sourced message that starts the regeneration turn after an edit.
+ * producer-sourced message that starts the regeneration turn after an edit.
  * @param event - the session event to test.
  * @returns the event narrowed to an edit trigger when matched.
  */
 export function isMessageToolsTrigger(event) {
     return event.type === 'user/message'
         && event.surfaceOp === 'append'
-        && event.data.source.kind === 'plugin'
-        && event.data.source.plugin === MESSAGE_TOOLS_PLUGIN
+        && isMessageToolsSource(event.data.source)
         && messageToolsOp(event.data.source) === 'edit-trigger';
 }
 /**
@@ -125,7 +153,6 @@ export function isMessageToolsTrigger(event) {
 export function isMessageToolsRestoreAssistant(event) {
     return event.type === 'user/message'
         && event.surfaceOp === 'append'
-        && event.data.source.kind === 'plugin'
-        && event.data.source.plugin === MESSAGE_TOOLS_PLUGIN
+        && isMessageToolsSource(event.data.source)
         && messageToolsOp(event.data.source) === 'restore-assistant';
 }

package/lib/types/restore-projection.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Restore-assistant message projection (seam registry S12): the pure
+ * `user/message` interpreter that rewrites a restore replay's derived message
+ * to assistant role with the model-facing frame stripped, plus the
+ * registration helper that probes the host for the capability and degrades to
+ * the framed user-role channel when it cannot carry the projection. The
+ * durable log is identical on both channels — the restore append keeps its
+ * `restore-assistant` source mark and its frame prefix; only the model-facing
+ * derivation differs.
+ * @module @khorsheed/dsh-client-message-tools/restore-projection
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import * as sessionApi from '@deepseek-ai/dsh-session';
+import type { SessionMessageProjection } from '@deepseek-ai/dsh-session';
+/**
+ * The `user/message` projection correcting restore replays at derivation
+ * time. It registers on the SHARED user-message vocabulary (a custom event
+ * type could never persist — S2), so the fold calls `project` synchronously
+ * for EVERY user message, inside append validation: it must be a pure
+ * pass-through (empty map) for anything without the restore mark, and it must
+ * NEVER throw — a throw atomically rejects the candidate append, so a
+ * throwing projection would break ordinary user messages instance-wide. Any
+ * malformed durable payload therefore also yields an empty map.
+ */
+export declare const restoreAssistantProjection: SessionMessageProjection<'user/message'>;
+/**
+ * Whether this host's surface fold can carry a `user/message` projection at
+ * all. 0.1.6-alpha.1 routes every event of a projected type through the
+ * projection plan and never joins it to the surface (probe-verified): a
+ * registered user/message projection would silently drop EVERY user message
+ * from the model context. This probe folds two synthetic events through the
+ * real `foldSurface` and accepts only the composing semantics the design
+ * needs — plain messages keep their node, and a restore replay keeps its
+ * node AND derives assistant-role with the frame stripped — so the channel
+ * stays dormant on 0.1.6-alpha.1 and lights up by itself on a host whose
+ * fold composes. Pure, synchronous, side-effect-free.
+ * @param fold - the host's surface fold, injectable for tests.
+ * @param derive - the host's single-event derivation, injectable for tests.
+ * @returns true when a registered user/message projection is safe.
+ */
+export declare function restoreProjectionFoldSupported(fold?: typeof sessionApi.foldSurface | undefined, derive?: typeof sessionApi.deriveEventMessage | undefined): boolean;
+/**
+ * Probe and register the restore-assistant projection, degrading to the
+ * framed user-role channel (which the durable events already carry) whenever
+ * the host cannot carry the projection: pre-0.1.6 (`registerMessageProjection`
+ * absent), a fold that cannot compose projections with surface membership, or
+ * a registration conflict (the projection slot is one-per-type per instance —
+ * a future official projection claiming user/message throws, and the plugin
+ * must not take the instance down with it).
+ * @param ctx - host context carrying the session store.
+ * @param foldSupported - fold-semantics probe, injectable for tests.
+ * @returns true when the projection channel is active.
+ */
+export declare function registerRestoreProjection(ctx: Context, foldSupported?: () => boolean): boolean;
+//# sourceMappingURL=restore-projection.d.ts.map

package/lib/types/restore-projection.js

@@ -0,0 +1,123 @@
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+// Value: the branded seq constructor the probe events require.
+import { SessionSeq } from '@deepseek-ai/dsh-session';
+// Namespace: foldSurface/deriveEventMessage are 0.1.6 additions — a named
+// import would fail module linking on a 0.1.5 host, so the probe reaches them
+// through the namespace object (absent members read as undefined).
+import * as sessionApi from '@deepseek-ai/dsh-session';
+import { RESTORED_ASSISTANT_NOTICE, messageToolsOp, restoreAssistantSource, stripRestoreAssistantFrame, } from './marker.js';
+/**
+ * The `user/message` projection correcting restore replays at derivation
+ * time. It registers on the SHARED user-message vocabulary (a custom event
+ * type could never persist — S2), so the fold calls `project` synchronously
+ * for EVERY user message, inside append validation: it must be a pure
+ * pass-through (empty map) for anything without the restore mark, and it must
+ * NEVER throw — a throw atomically rejects the candidate append, so a
+ * throwing projection would break ordinary user messages instance-wide. Any
+ * malformed durable payload therefore also yields an empty map.
+ */
+export const restoreAssistantProjection = {
+    type: 'user/message',
+    project(event, context) {
+        try {
+            const source = event.data?.source;
+            if (messageToolsOp(source) !== 'restore-assistant')
+                return new Map();
+            // The current message at the candidate's own seq: a prior projection's
+            // rewrite wins, then the committed window entry (fold replay), then the
+            // candidate's own data (live append validation, where the window
+            // excludes the candidate). Mirrors the official image-offload
+            // projection's message fetch.
+            const committed = context.events[event.seq - context.baseSeq];
+            const message = context.messages.get(event.seq)
+                ?? (committed?.type === 'user/message' ? committed.data : undefined)
+                ?? event.data;
+            const content = message.content.map(block => block.type === 'text' && typeof block.text === 'string'
+                ? { ...block, text: stripRestoreAssistantFrame(block.text) }
+                : block);
+            return new Map([[event.seq, { ...message, role: 'assistant', content }]]);
+        }
+        catch {
+            return new Map();
+        }
+    },
+};
+/** One synthetic user/message event for the fold-semantics probe. */
+function probeEvent(seq, text, source) {
+    return {
+        type: 'user/message',
+        seq: SessionSeq(seq),
+        time: 0,
+        data: createUserMessage({ content: [{ type: 'text', text }], source }),
+        surfaceOp: 'append',
+    };
+}
+/**
+ * Whether this host's surface fold can carry a `user/message` projection at
+ * all. 0.1.6-alpha.1 routes every event of a projected type through the
+ * projection plan and never joins it to the surface (probe-verified): a
+ * registered user/message projection would silently drop EVERY user message
+ * from the model context. This probe folds two synthetic events through the
+ * real `foldSurface` and accepts only the composing semantics the design
+ * needs — plain messages keep their node, and a restore replay keeps its
+ * node AND derives assistant-role with the frame stripped — so the channel
+ * stays dormant on 0.1.6-alpha.1 and lights up by itself on a host whose
+ * fold composes. Pure, synchronous, side-effect-free.
+ * @param fold - the host's surface fold, injectable for tests.
+ * @param derive - the host's single-event derivation, injectable for tests.
+ * @returns true when a registered user/message projection is safe.
+ */
+export function restoreProjectionFoldSupported(fold = sessionApi.foldSurface, derive = sessionApi.deriveEventMessage) {
+    try {
+        if (typeof fold !== 'function' || typeof derive !== 'function')
+            return false;
+        const events = [
+            probeEvent(0, 'probe', { kind: 'user' }),
+            probeEvent(1, `${RESTORED_ASSISTANT_NOTICE}\nprobe answer`, restoreAssistantSource()),
+        ];
+        const folded = fold(events, [restoreAssistantProjection]);
+        if (folded.nodes.length !== events.length)
+            return false;
+        const derived = derive(events[1], folded.projectedMessages);
+        return derived?.role === 'assistant'
+            && derived.content.some(block => block.type === 'text' && block.text === 'probe answer');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Probe and register the restore-assistant projection, degrading to the
+ * framed user-role channel (which the durable events already carry) whenever
+ * the host cannot carry the projection: pre-0.1.6 (`registerMessageProjection`
+ * absent), a fold that cannot compose projections with surface membership, or
+ * a registration conflict (the projection slot is one-per-type per instance —
+ * a future official projection claiming user/message throws, and the plugin
+ * must not take the instance down with it).
+ * @param ctx - host context carrying the session store.
+ * @param foldSupported - fold-semantics probe, injectable for tests.
+ * @returns true when the projection channel is active.
+ */
+export function registerRestoreProjection(ctx, foldSupported = restoreProjectionFoldSupported) {
+    const sessions = ctx.sessions;
+    if (typeof sessions.registerMessageProjection !== 'function') {
+        ctx.logger.info('message-tools: host has no sessions.registerMessageProjection — restored assistant text stays in the framed user-role channel');
+        return false;
+    }
+    if (!foldSupported()) {
+        ctx.logger.warn('message-tools: host message-projection fold drops projected user/message events from the surface — restored assistant text stays in the framed user-role channel');
+        return false;
+    }
+    try {
+        const dispose = sessions.registerMessageProjection(restoreAssistantProjection);
+        // The host's returned disposer is fiber-owned and idempotent (cordis
+        // effect disposal re-entry is a no-op); wiring it here as well keeps
+        // unregister-on-unload exact even if a future host binds it elsewhere.
+        ctx.effect(() => () => dispose(), 'message-tools: restore-assistant projection');
+        return true;
+    }
+    catch {
+        ctx.logger.warn('message-tools: a user/message message-projection is already registered — restored assistant text stays in the framed user-role channel');
+        return false;
+    }
+}

package/lib/types/withdraw.js

@@ -111,10 +111,10 @@ function joinAssistantMessageText(blocks) {
  * (the message left the surface through another producer, e.g. compaction).
  *
  * `sourceEventSeqs` is authoritative for the shadowed *surface* nodes, but an
- * interrupted assistant step may exist only as `assistant/chunk` events (no
- * `assistant/message` ever landed). Those chunks are not surface nodes, so
- * they are absent from `sourceEventSeqs`. The replacement's own `start` and
- * `seq` delimit the whole withdrawn log interval — `[start, seq)` — and are
+ * interrupted assistant step may exist only as `assistant/attempt` events (no
+ * `assistant/message` ever landed). Attempts are not surface nodes, so
+ * they are absent from `sourceEventSeqs`. The replacement's own `startSeq` and
+ * `seq` delimit the whole withdrawn log interval — `[startSeq, seq)` — and are
  * still read from the replacement itself, never guessed from another producer.
  */
 function findWithdrawnSpan(events, targetSeq) {
@@ -127,7 +127,7 @@ function findWithdrawnSpan(events, targetSeq) {
         if (sources?.includes(targetSeq) !== true)
             continue;
         const span = [];
-        for (let seq = event.surfaceOp.start; seq < event.seq; seq++)
+        for (let seq = event.surfaceOp.startSeq; seq < event.seq; seq++)
             span.push(seq);
         return span;
     }
@@ -140,64 +140,27 @@ function findWithdrawnSpan(events, targetSeq) {
  * restore-assistant replays already carry the frame). Skipped: withdrawal
  * placeholders, edit triggers, other plugin context, and tool calls/results.
  *
- * Assistant text normally comes from `assistant/message` surface events. A
- * turn that was interrupted before finalization may never emit
- * `assistant/message`; its visible content survives only as `assistant/chunk`
- * rows. Those chunks are folded into one assistant replay per step when no
- * final `assistant/message` exists for that step, so withdrawing/restoring an
- * interrupted reply does not lose the partial assistant content.
+ * Assistant text normally comes from `assistant/message` surface events (a
+ * cancelled turn finalizes its delivered prefix there with `interrupted:
+ * true`). An attempt that committed no surface message — failed, retried, or
+ * stream-error — settles as an `assistant/attempt` log event carrying its
+ * exact compact stream. Each such attempt folds into one assistant replay
+ * when no final `assistant/message` exists for that step, so
+ * withdrawing/restoring an interrupted reply does not lose the partial
+ * assistant content. A retried step's earlier attempts are superseded by the
+ * step's final message and do not replay.
  */
 function replayEntries(events, spanSeqs) {
     const entries = [];
-    let pending;
+    // A step's final message supersedes its attempts; collect the finalized
+    // steps first so an attempt is skipped regardless of log order.
     const finalizedSteps = new Set();
-    const flushPending = () => {
-        if (pending === undefined)
-            return;
-        if (!pending.finalized) {
-            const text = [...pending.text.values()].join('');
-            const reasoning = [...pending.reasoning.values()].join('');
-            const replay = text !== '' ? text : reasoning;
-            if (replay !== '') {
-                entries.push({
-                    role: 'assistant',
-                    text: `${RESTORED_ASSISTANT_NOTICE}\n${replay}`,
-                    sourceSeq: pending.sourceSeq,
-                });
-            }
-        }
-        pending = undefined;
-    };
-    const pushChunk = (event) => {
-        if (finalizedSteps.has(`${event.data.turn}:${event.data.step}`))
-            return;
-        if (pending === undefined
-            || pending.turn !== event.data.turn
-            || pending.step !== event.data.step) {
-            flushPending();
-            pending = {
-                turn: event.data.turn,
-                step: event.data.step,
-                sourceSeq: event.seq,
-                text: new Map(),
-                reasoning: new Map(),
-                finalized: false,
-            };
-        }
-        const chunk = event.data.chunk;
-        if (chunk.type === 'text-delta') {
-            pending.text.set(chunk.index, (pending.text.get(chunk.index) ?? '') + chunk.text);
-        }
-        else if (chunk.type === 'block-end' && chunk.block.type === 'text') {
-            pending.text.set(chunk.index, chunk.block.text);
-        }
-        else if (chunk.type === 'reasoning-delta') {
-            pending.reasoning.set(chunk.index, (pending.reasoning.get(chunk.index) ?? '') + chunk.text);
-        }
-        else if (chunk.type === 'block-end' && chunk.block.type === 'reasoning') {
-            pending.reasoning.set(chunk.index, chunk.block.text);
+    for (const seq of spanSeqs) {
+        const event = events[seq];
+        if (event?.type === 'assistant/message') {
+            finalizedSteps.add(`${event.data.turn}:${event.data.step}`);
         }
-    };
+    }
     const pushAssistantText = (text, sourceSeq) => {
         if (text !== '') {
             entries.push({ role: 'assistant', text: `${RESTORED_ASSISTANT_NOTICE}\n${text}`, sourceSeq });
@@ -208,16 +171,16 @@ function replayEntries(events, spanSeqs) {
         if (event === undefined)
             continue;
         if (isMessageToolsEdit(event)) {
-            flushPending();
             entries.push({ role: 'user', content: event.data.content, sourceSeq: seq });
             continue;
         }
-        if (event.type === 'assistant/chunk') {
-            pushChunk(event);
+        if (event.type === 'assistant/attempt') {
+            if (finalizedSteps.has(`${event.data.turn}:${event.data.step}`))
+                continue;
+            pushAssistantText(joinAttemptStreamText(event.data.stream), seq);
             continue;
         }
         if (event.type === 'user/message') {
-            flushPending();
             if (event.surfaceOp !== 'append')
                 continue;
             if (event.data.source.kind === 'user' || isMessageToolsRestore(event)) {
@@ -231,25 +194,54 @@ function replayEntries(events, spanSeqs) {
             continue;
         }
         if (event.type === 'assistant/message') {
-            // A finalized step supersedes any pending chunk accumulation for the
-            // same step: flush without emitting the partial, then replay the final.
-            finalizedSteps.add(`${event.data.turn}:${event.data.step}`);
-            if (pending !== undefined
-                && pending.turn === event.data.turn
-                && pending.step === event.data.step) {
-                pending.finalized = true;
-            }
-            flushPending();
             pushAssistantText(joinAssistantMessageText(event.data.message.content), seq);
             continue;
         }
-        // Log-only events (boundaries, headers, titles) do not split a chunk run;
-        // the pending assistant step is flushed at the next replayable boundary or
-        // when a different step starts.
+        // Log-only events (boundaries, headers, titles) contribute nothing.
     }
-    flushPending();
     return entries;
 }
+/**
+ * Join one attempt's compact stream into its visible text. Text deltas win;
+ * reasoning is the fallback so an attempt that streamed only reasoning does
+ * not lose the only assistant content the user saw (the same preference
+ * {@link joinAssistantMessageText} applies to finalized messages). Packed
+ * delta runs append per block index; a raw `block-end` record carries the
+ * assembled block and replaces its index's accumulated deltas. Tool-call
+ * runs never replay (their side effects are not replayable).
+ */
+function joinAttemptStreamText(stream) {
+    const text = new Map();
+    const reasoning = new Map();
+    const append = (map, index, fragment) => {
+        map.set(index, (map.get(index) ?? '') + fragment);
+    };
+    for (const record of stream) {
+        if (record.type === 'text-chunks') {
+            append(text, record.index, record.texts.join(''));
+        }
+        else if (record.type === 'reasoning-chunks') {
+            append(reasoning, record.index, record.texts.join(''));
+        }
+        else if (record.type === 'chunk') {
+            const chunk = record.chunk;
+            if (chunk.type === 'text-delta') {
+                append(text, chunk.index, chunk.text);
+            }
+            else if (chunk.type === 'reasoning-delta') {
+                append(reasoning, chunk.index, chunk.text);
+            }
+            else if (chunk.type === 'block-end' && chunk.block.type === 'text') {
+                text.set(chunk.index, chunk.block.text);
+            }
+            else if (chunk.type === 'block-end' && chunk.block.type === 'reasoning') {
+                reasoning.set(chunk.index, chunk.block.text);
+            }
+        }
+    }
+    const joined = [...text.values()].join('');
+    return joined !== '' ? joined : [...reasoning.values()].join('');
+}
 /**
  * Plan a restore: the target must be an editable user message (the same
  * vocabulary as withdrawal — original, restore replay, or edit replacement)

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Message Tools",
+    "description": "Edit or withdraw sent messages; withdrawal truly leaves the model context."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "消息工具",
+    "description": "编辑或撤回已发送的消息，撤回内容真正离开模型上下文。"
+  }
+}

package/package.json

@@ -7,7 +7,7 @@
     "cordis",
     "messages"
   ],
-  "version": "0.2.0",
+  "version": "0.3.1",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -37,7 +37,8 @@
       "default": "./lib/typert.remote-client.js"
     },
     "./src/*": "./src/*",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
   },
   "dsh": {
     "bundle": {
@@ -53,11 +54,14 @@
       "platform": "web"
     },
     "compat": {
-      "minHost": "0.1.2-rc.1",
-      "verifiedHost": "0.1.2-rc.1"
+      "minHost": "0.1.5-rc.1",
+      "verifiedHost": "0.1.7-rc.1"
     }
   },
   "license": "MIT",
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-api-remotes": "^0.1.0-rc.6",
@@ -72,30 +76,6 @@
     "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.6",
     "react": "^18.2.0"
   },
-  "devDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-api-remotes": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-api-session-controller": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-client-locale": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-client-store": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-client-test-runtime": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-client-ui-chat": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-client-ui-model-selection": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-invariants": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-llm": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-session": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-typert-protocol": "^0.1.2-rc.1",
-    "@testing-library/react": "^16.1.0",
-    "@types/node": "^26.2.0",
-    "@types/react": "~18.3.1",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0"
-  },
   "files": [
     "lib",
     "cordis.patch.yml",
@@ -104,6 +84,7 @@
     "lib/typert.remote-client.d.ts",
     "lib/typert.remote-client.js",
     "LICENSE",
+    "locale/*.json",
     "CHANGELOG.md"
   ]
 }