@khorsheed/dsh-client-message-tools 0.1.0

package/lib/types/withdraw.d.ts

@@ -0,0 +1,112 @@
+import type { SessionEvent } from '@deepseek-ai/dsh-session/types';
+/** Why a withdrawal cannot be planned. */
+export type WithdrawalPlanFailure = 'target-not-found' | 'not-a-user-message' | 'already-withdrawn';
+/** The validated replacement intent for one withdrawal. */
+export interface WithdrawalPlan {
+    /** Seq of the withdrawn user message (a current surface node). */
+    readonly start: number;
+    /** Seq of the last current surface node; the span replaces [start, end]. */
+    readonly end: number;
+    /** Every shadowed surface node, in surface order (surface validation requires the complete set). */
+    readonly sourceEventSeqs: readonly number[];
+}
+/** Planning outcome: a replacement intent or a failure code. */
+export type WithdrawalPlanResult = {
+    readonly ok: true;
+    readonly plan: WithdrawalPlan;
+} | {
+    readonly ok: false;
+    readonly code: WithdrawalPlanFailure;
+};
+/**
+ * Plan a withdrawal: the target must be an editable user message (original,
+ * restore replay, or edit replacement — see `isEditableTarget`) still present
+ * on the live surface; the span covers it and every surface node after it.
+ * @param events - the full session log (seq === index).
+ * @param surfaceNodes - the current model-visible surface seqs, in order.
+ * @param targetSeq - seq of the user message to withdraw.
+ * @returns the replacement intent, or the failure code.
+ */
+export declare function planWithdrawal(events: readonly SessionEvent[], surfaceNodes: readonly number[], targetSeq: number): WithdrawalPlanResult;
+/** Why an edit cannot be planned. */
+export type EditPlanFailure = 'target-not-found' | 'not-a-user-message' | 'already-withdrawn' | 'empty-text';
+/** Planning outcome: a replacement intent or a failure code. */
+export type EditPlanResult = {
+    readonly ok: true;
+    readonly plan: WithdrawalPlan;
+} | {
+    readonly ok: false;
+    readonly code: EditPlanFailure;
+};
+/**
+ * Plan an edit: the target must be an editable user message still present on
+ * the live surface, and the new text must be non-blank. The span covers the
+ * target and every surface node after it — editing an old message discards
+ * what followed it. The replacement's content is the new text (no
+ * placeholder), so the model context reads the edited message in place.
+ * @param events - the full session log (seq === index).
+ * @param surfaceNodes - the current model-visible surface seqs, in order.
+ * @param targetSeq - seq of the user message to edit.
+ * @param text - the edited text.
+ * @returns the replacement intent, or the failure code.
+ */
+export declare function planEdit(events: readonly SessionEvent[], surfaceNodes: readonly number[], targetSeq: number, text: string): EditPlanResult;
+/** Why a restore cannot be planned. */
+export type RestorePlanFailure = 'target-not-found' | 'not-a-user-message' | 'not-withdrawn';
+/**
+ * One replayed entry of a restored span, in original order. User entries
+ * replay content blocks verbatim (originals, edit replacements — whose
+ * content IS the last edit's new text — and earlier restore replays);
+ * assistant entries carry the reply's joined text, framed for the model.
+ */
+export type RestoreReplayEntry = {
+    readonly role: 'user';
+    /** The entry's content blocks, replayed verbatim. */
+    readonly content: SessionEvent<'user/message'>['data']['content'];
+    /** Seq of the original event this entry replays. */
+    readonly sourceSeq: number;
+} | {
+    readonly role: 'assistant';
+    /** The model-facing text (frame included — see RESTORED_ASSISTANT_NOTICE). */
+    readonly text: string;
+    /** Seq of the original event this entry replays. */
+    readonly sourceSeq: number;
+};
+/** The validated restore intent for one withdrawn message. */
+export interface RestorePlan {
+    /**
+     * Every replayable entry of the withdrawn span, in original (surface)
+     * order; the host appends them back-to-back at the tail. Never empty: the
+     * target message itself always replays. Tool calls/results never replay —
+     * the call/result pairing cannot be re-entered and their side effects are
+     * not replayable; the assistant text already summarizes them.
+     */
+    readonly entries: readonly RestoreReplayEntry[];
+}
+/** Restore planning outcome: a restore intent or a failure code. */
+export type RestorePlanResult = {
+    readonly ok: true;
+    readonly plan: RestorePlan;
+} | {
+    readonly ok: false;
+    readonly code: RestorePlanFailure;
+};
+/**
+ * Plan a restore: the target must be an editable user message (the same
+ * vocabulary as withdrawal — original, restore replay, or edit replacement)
+ * that is no longer on the live surface (i.e. withdrawn). Restoring an edit
+ * replacement replays the span's last edit text — the replacement's content
+ * IS the new text. The surface model is positional — a replaced span folds
+ * into exactly one node — so the withdrawn span can never be put back in
+ * place; restore replays the span's replayable content (user messages, the
+ * last edit's new text, assistant text) as fresh tail messages in original
+ * order. When no message-tools replacement cites the target (a foreign
+ * shadowing, e.g. compaction), only the target message replays — the span
+ * boundary is never re-guessed.
+ * @param events - the full session log (seq === index).
+ * @param surfaceNodes - the current model-visible surface seqs.
+ * @param targetSeq - seq of the withdrawn user message to restore.
+ * @returns the restore intent, or the failure code.
+ */
+export declare function planRestore(events: readonly SessionEvent[], surfaceNodes: readonly number[], targetSeq: number): RestorePlanResult;
+//# sourceMappingURL=withdraw.d.ts.map

package/lib/types/withdraw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withdraw.d.ts","sourceRoot":"","sources":["../../src/withdraw.ts"],"names":[],"mappings":"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"}

package/lib/types/withdraw.js

@@ -0,0 +1,279 @@
+/**
+ * Withdrawal planning: a pure fold from the session log and the live surface
+ * to the replacement intent. Kept free of cordis and Session internals so the
+ * unit tests drive it directly; the service only validates and appends.
+ * @module @khorsheed/dsh-client-message-tools/withdraw
+ */
+import { isAppendSurfaceEvent } from '@deepseek-ai/dsh-session/surface';
+import { RESTORED_ASSISTANT_NOTICE, isMessageToolsEdit, isMessageToolsReplacement, isMessageToolsRestore, isMessageToolsRestoreAssistant, } from './marker.js';
+/**
+ * Whether a target seq names an editable user message: an append-surface
+ * user-source message (an original), a message-tools restore replay (a
+ * restored row withdraws and edits like the message it replays), or a
+ * message-tools edit replacement (edit chains — the previous edit's
+ * replacement is the surface node). Assistant-text restore replays carry no
+ * actions and are excluded.
+ */
+function isEditableTarget(event) {
+    if (event === undefined || event.type !== 'user/message')
+        return false;
+    if (isAppendSurfaceEvent(event)) {
+        return event.data.source.kind === 'user' || isMessageToolsRestore(event);
+    }
+    return isMessageToolsEdit(event);
+}
+/** The span [target, surface tail] with full provenance, or undefined when off-surface. */
+function surfaceSpan(surfaceNodes, targetSeq) {
+    const startIndex = surfaceNodes.indexOf(targetSeq);
+    if (startIndex === -1)
+        return undefined;
+    const sourceEventSeqs = surfaceNodes.slice(startIndex);
+    const end = sourceEventSeqs[sourceEventSeqs.length - 1];
+    /* v8 ignore next -- the slice is non-empty by construction (startIndex names a member) */
+    if (end === undefined)
+        return undefined;
+    return { start: targetSeq, end, sourceEventSeqs };
+}
+/**
+ * Plan a withdrawal: the target must be an editable user message (original,
+ * restore replay, or edit replacement — see `isEditableTarget`) still present
+ * on the live surface; the span covers it and every surface node after it.
+ * @param events - the full session log (seq === index).
+ * @param surfaceNodes - the current model-visible surface seqs, in order.
+ * @param targetSeq - seq of the user message to withdraw.
+ * @returns the replacement intent, or the failure code.
+ */
+export function planWithdrawal(events, surfaceNodes, targetSeq) {
+    const target = events[targetSeq];
+    if (target === undefined)
+        return { ok: false, code: 'target-not-found' };
+    if (!isEditableTarget(target)) {
+        return { ok: false, code: 'not-a-user-message' };
+    }
+    const span = surfaceSpan(surfaceNodes, targetSeq);
+    if (span === undefined)
+        return { ok: false, code: 'already-withdrawn' };
+    return { ok: true, plan: span };
+}
+/**
+ * Plan an edit: the target must be an editable user message still present on
+ * the live surface, and the new text must be non-blank. The span covers the
+ * target and every surface node after it — editing an old message discards
+ * what followed it. The replacement's content is the new text (no
+ * placeholder), so the model context reads the edited message in place.
+ * @param events - the full session log (seq === index).
+ * @param surfaceNodes - the current model-visible surface seqs, in order.
+ * @param targetSeq - seq of the user message to edit.
+ * @param text - the edited text.
+ * @returns the replacement intent, or the failure code.
+ */
+export function planEdit(events, surfaceNodes, targetSeq, text) {
+    if (text.trim() === '')
+        return { ok: false, code: 'empty-text' };
+    const target = events[targetSeq];
+    if (target === undefined)
+        return { ok: false, code: 'target-not-found' };
+    if (!isEditableTarget(target)) {
+        return { ok: false, code: 'not-a-user-message' };
+    }
+    const span = surfaceSpan(surfaceNodes, targetSeq);
+    if (span === undefined)
+        return { ok: false, code: 'already-withdrawn' };
+    return { ok: true, plan: span };
+}
+/** Join the text blocks of one message's content into one plain string. */
+function joinText(blocks) {
+    return blocks
+        .filter((block) => block.type === 'text'
+        && typeof block.text === 'string')
+        .map(block => block.text)
+        .join('');
+}
+/**
+ * Join an assistant message's visible text. Normal replies use text blocks;
+ * interrupted replies may contain only reasoning. Prefer text when present,
+ * otherwise preserve the reasoning so a restore does not drop the only
+ * assistant content the user saw.
+ */
+function joinAssistantMessageText(blocks) {
+    const text = joinText(blocks);
+    if (text !== '')
+        return text;
+    return blocks
+        .filter((block) => block.type === 'reasoning'
+        && typeof block.text === 'string')
+        .map(block => block.text)
+        .join('');
+}
+/**
+ * The full log seqs shadowed by the latest message-tools withdrawal
+ * replacement citing `targetSeq`, or undefined when no such replacement exists
+ * (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
+ * still read from the replacement itself, never guessed from another producer.
+ */
+function findWithdrawnSpan(events, targetSeq) {
+    for (let index = events.length - 1; index > targetSeq; index--) {
+        const event = events[index];
+        if (event !== undefined && isMessageToolsReplacement(event) && event.sourceEventSeqs?.includes(targetSeq)) {
+            const span = [];
+            for (let seq = event.surfaceOp.start; seq < event.seq; seq++)
+                span.push(seq);
+            return span;
+        }
+    }
+    return undefined;
+}
+/**
+ * Fold one withdrawn span into its replay entries, in span (original) order.
+ * Replayed: user-source messages, edit replacements (their content is the
+ * last edit's new text), earlier restore replays, and assistant text (framed;
+ * 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.
+ */
+function replayEntries(events, spanSeqs) {
+    const entries = [];
+    let pending;
+    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);
+        }
+    };
+    const pushAssistantText = (text, sourceSeq) => {
+        if (text !== '') {
+            entries.push({ role: 'assistant', text: `${RESTORED_ASSISTANT_NOTICE}\n${text}`, sourceSeq });
+        }
+    };
+    for (const seq of spanSeqs) {
+        const event = events[seq];
+        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);
+            continue;
+        }
+        if (event.type === 'user/message') {
+            flushPending();
+            if (event.surfaceOp !== 'append')
+                continue;
+            if (event.data.source.kind === 'user' || isMessageToolsRestore(event)) {
+                entries.push({ role: 'user', content: event.data.content, sourceSeq: seq });
+            }
+            else if (isMessageToolsRestoreAssistant(event)) {
+                // Restore-assistant replays already carry the model-facing frame; do
+                // not add a second one.
+                entries.push({ role: 'assistant', text: joinText(event.data.content), sourceSeq: seq });
+            }
+            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.
+    }
+    flushPending();
+    return entries;
+}
+/**
+ * Plan a restore: the target must be an editable user message (the same
+ * vocabulary as withdrawal — original, restore replay, or edit replacement)
+ * that is no longer on the live surface (i.e. withdrawn). Restoring an edit
+ * replacement replays the span's last edit text — the replacement's content
+ * IS the new text. The surface model is positional — a replaced span folds
+ * into exactly one node — so the withdrawn span can never be put back in
+ * place; restore replays the span's replayable content (user messages, the
+ * last edit's new text, assistant text) as fresh tail messages in original
+ * order. When no message-tools replacement cites the target (a foreign
+ * shadowing, e.g. compaction), only the target message replays — the span
+ * boundary is never re-guessed.
+ * @param events - the full session log (seq === index).
+ * @param surfaceNodes - the current model-visible surface seqs.
+ * @param targetSeq - seq of the withdrawn user message to restore.
+ * @returns the restore intent, or the failure code.
+ */
+export function planRestore(events, surfaceNodes, targetSeq) {
+    const target = events[targetSeq];
+    if (target === undefined)
+        return { ok: false, code: 'target-not-found' };
+    if (!isEditableTarget(target))
+        return { ok: false, code: 'not-a-user-message' };
+    if (surfaceNodes.includes(targetSeq))
+        return { ok: false, code: 'not-withdrawn' };
+    const span = findWithdrawnSpan(events, targetSeq);
+    const entries = span === undefined
+        ? [{ role: 'user', content: target.data.content, sourceSeq: targetSeq }]
+        : replayEntries(events, span);
+    return { ok: true, plan: { entries } };
+}

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "@khorsheed/dsh-client-message-tools",
+  "description": "User-message edit (withdraw and resend) and withdrawal: the withdrawal writes a surface replacement that hides the message and everything after it from the model, with a chat divider marking the spot",
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "cordis",
+    "messages"
+  ],
+  "version": "0.1.0",
+  "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"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
+    "./typert": {
+      "types": "./lib/typert.host.d.ts",
+      "default": "./lib/typert.host.js"
+    },
+    "./remote": {
+      "types": "./lib/typert.remote-client.d.ts",
+      "default": "./lib/typert.remote-client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-model-selection"
+      ],
+      "platform": "web"
+    },
+    "compat": {
+      "minHost": "0.1.0-rc.8",
+      "verifiedHost": "0.1.1-rc.2"
+    }
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-api-remotes": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-model-selection": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.6",
+    "react": "^18.2.0"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "^0.1.1-rc.1",
+    "@deepseek-ai/dsh-api-remotes": "^0.1.1-rc.1",
+    "@deepseek-ai/dsh-client-locale": "^0.1.1-rc.1",
+    "@deepseek-ai/dsh-client-runtime": "^0.1.1-rc.1",
+    "@deepseek-ai/dsh-client-test-runtime": "^0.1.1-rc.1",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.1-rc.1",
+    "@deepseek-ai/dsh-client-ui-model-selection": "^0.1.1-rc.1",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.1-rc.1",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.1-rc.1",
+    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.1",
+    "@deepseek-ai/dsh-llm": "^0.1.1-rc.1",
+    "@deepseek-ai/dsh-session": "^0.1.1-rc.1",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.1-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",
+    "lib/typert.host.d.ts",
+    "lib/typert.host.js",
+    "lib/typert.remote-client.d.ts",
+    "lib/typert.remote-client.js",
+    "LICENSE",
+    "CHANGELOG.md"
+  ]
+}