dsh-edit-turn 0.3.2 → 0.5.0

package/lib/index.js

@@ -80,7 +80,7 @@ export const PLUGIN_ID = 'dsh-edit-turn'
 export const name = PLUGIN_ID
 
 /** Keep in sync with package.json and lib/client.js. */
-export const PLUGIN_VERSION = '0.3.2'
+export const PLUGIN_VERSION = '0.5.0'
 
 // A ring of the last few requests, answering "did the browser half even ask, and
 // what did it get?" without needing its console. Read-only diagnostics: the
@@ -164,6 +164,14 @@ export const Config =
          * the official surface replacement.
          */
         replyMode: z.string().default('auto'),
+        /**
+         * Which editor presentation the browser half draws. `frame` outlines the
+         * whole message row (reference-UI style); `bubble` is exactly the
+         * message bubble; `center` is a large centred panel. The setting exists
+         * because the best shape is a matter of taste and was hard to pick
+         * without trying them side by side.
+         */
+        editorStyle: z.union([z.const('frame'), z.const('bubble'), z.const('center')]).default('frame'),
       })
 
 // ---------------------------------------------------------------------------
@@ -1300,6 +1308,25 @@ export function editableReplies(events, surfaceNodes, options = {}) {
     if (!patch && text.trim() === '') continue
     if (patch && blocks.every((block) => block.text.trim() === '')) continue
     const turn = turnOf.get(event.seq)
+    // One turn runs many steps, and every step's assistant message carries its
+    // own reasoning. The answer's row is the one with the action strip, so its
+    // block list is widened to the whole turn: every reasoning and every answer
+    // text of that turn is offered, each annotated with the seq it lives in.
+    let listed = blocks.map((block) => ({ ...block, seq: event.seq }))
+    const carriesAnswer = blocks.some((block) => block.kind === 'text' && block.text.trim() !== '')
+    if (patch && carriesAnswer && typeof turn === 'number') {
+      const acrossTurn = []
+      for (const other of events) {
+        if (!isAssistantReply(other) || turnOf.get(other.seq) !== turn) continue
+        if (!nodeIndex.has(other.seq)) continue
+        const otherData = other.data && typeof other.data === 'object' ? other.data : {}
+        const otherMessage = otherData.message && typeof otherData.message === 'object' ? otherData.message : otherData
+        for (const block of projectedBlocks(otherMessage, other.seq, patches)) {
+          acrossTurn.push({ ...block, seq: other.seq })
+        }
+      }
+      if (acrossTurn.length > listed.length) listed = acrossTurn
+    }
     out.push({
       seq: event.seq,
       turn: typeof turn === 'number' ? turn : null,
@@ -1311,7 +1338,7 @@ export function editableReplies(events, surfaceNodes, options = {}) {
       patched: blocks.some((block) => block.patched),
       // Present only where the editor can target one: the replay path can only
       // replace the whole reply, so it has no block picker.
-      ...(patch ? { blocks } : {}),
+      ...(patch ? { blocks: listed } : {}),
     })
   }
   return out
@@ -1706,7 +1733,12 @@ async function stateOf(ctx, sessionId, config) {
     // path (a chip that may draw its own thumbnail); both are answered from a
     // live service probe, so the editor never promises what the host cannot do.
     capabilities: { attachments: store !== null, preview: canPreviewAttachments(store) },
-    config: { confirm: config.confirm, replyMode: config.replyMode, patch: config.patch === true },
+    config: {
+      confirm: config.confirm,
+      replyMode: config.replyMode,
+      patch: config.patch === true,
+      editorStyle: config.editorStyle,
+    },
     version: PLUGIN_VERSION,
   }
 }
@@ -1809,7 +1841,82 @@ export function buildCorrection(plan, text, turn, step) {
   }
 }
 
+/**
+ * The all-blocks save: one plugin record carrying a target per edited block,
+ * possibly across several messages of the same turn. Each target is planned
+ * exactly like a single-block save, and unchanged blocks are simply left out.
+ *
+ * @param ctx - cordis context.
+ * @param sessionId - the addressed session.
+ * @param body - `{ targets: [{ seq, blockIndex, kind, text }] }`.
+ * @param config - plugin config.
+ * @returns the same shape `/apply` returns for a reply patch.
+ */
+async function applyTargetsEdit(ctx, sessionId, body, config) {
+  const targets = Array.isArray(body.targets) ? body.targets : []
+  if (targets.length === 0 || targets.length > MAX_PARTS) {
+    throw new HttpError(400, 'invalid', 'targets must be a nonempty, bounded array')
+  }
+  for (const target of targets) {
+    if (target === null || typeof target !== 'object') throw new HttpError(400, 'invalid', 'each target must be an object')
+    if (typeof target.text !== 'string' || target.text.trim() === '') throw new HttpError(400, 'invalid', 'an edited block cannot be empty')
+    if (target.text.length > MAX_TEXT) throw new HttpError(400, 'invalid', 'the revised block is too long')
+  }
+  const session = await resolveSession(ctx, sessionId)
+  if (!session || typeof session.append !== 'function') {
+    throw new HttpError(409, 'session-not-active', 'the session is not open in DSH')
+  }
+  const events = await readEvents(ctx, sessionId)
+  if (!events) throw new HttpError(404, 'session-not-found', 'no session log for this id')
+  if (isBusy(events)) throw new HttpError(409, 'busy', 'the session is still working')
+  const surfaceNodes = surfaceOf(ctx, sessionId, events)
+  const patches = patchesOf(events)
+  const plans = []
+  for (const target of targets) {
+    let plan
+    try {
+      plan = planRollback(events, surfaceNodes, { seq: target.seq, blockIndex: target.blockIndex, kind: target.kind }, { patches, patch: config.patch === true })
+    } catch (error) {
+      if (error instanceof EditPlanError) {
+        const status = error.code === 'not-editable' ? 400 : 409
+        throw new HttpError(status, error.code, error.message)
+      }
+      throw error
+    }
+    if (plan.patch !== true) throw new HttpError(400, 'not-editable', 'all-blocks editing needs the in-place reply path')
+    if (target.text !== plan.original) plans.push({ plan, text: target.text })
+  }
+  if (plans.length === 0) {
+    return { kind: 'reply', applied: false, unchanged: true, patch: true, shadowed: [], targets: [] }
+  }
+  if (typeof sessionApi.appendPluginRecord !== 'function') {
+    throw new HttpError(409, 'unsupported', 'this harness does not expose plugin records; reply edits need the replay path')
+  }
+  let recordSeq
+  try {
+    recordSeq = sessionApi.appendPluginRecord(
+      session,
+      PATCH_TYPE,
+      buildPatchData(plans.map(({ plan, text }) => ({ seq: plan.targetSeq, blockIndex: plan.blockIndex, kind: plan.kind, text }))),
+    )
+  } catch (error) {
+    throw new HttpError(409, 'stale', `the session refused the patch record: ${String((error && error.message) || error)}`)
+  }
+  const flush = await flushSession(ctx, session)
+  return {
+    kind: 'reply',
+    applied: true,
+    mode: 'patch',
+    patch: true,
+    recordSeq,
+    targets: plans.map(({ plan, text }) => ({ seq: plan.targetSeq, blockIndex: plan.blockIndex, kind: plan.kind, text, original: plan.original })),
+    shadowed: [],
+    ...flush,
+  }
+}
+
 async function applyEdit(ctx, sessionId, body, config) {
+  if (Array.isArray(body.targets) && body.targets.length > 0) return applyTargetsEdit(ctx, sessionId, body, config)
   const text = typeof body.text === 'string' ? body.text : ''
   if (text.trim() === '') throw new HttpError(400, 'invalid', 'the revised message cannot be empty')
   if (text.length > MAX_TEXT) throw new HttpError(400, 'invalid', 'the revised message is too long')
@@ -1828,7 +1935,9 @@ async function applyEdit(ctx, sessionId, body, config) {
   let plan
   try {
     plan = planRollback(events, surfaceNodes, {
-      seq: typeof body.seq === 'number' ? body.seq : undefined,
+      // A block from another step of the same turn names its own seq; that is
+      // the message the projection has to patch.
+      seq: typeof body.targetSeq === 'number' ? body.targetSeq : typeof body.seq === 'number' ? body.seq : undefined,
       messageId: typeof body.messageId === 'string' ? body.messageId : undefined,
       turn: typeof body.turn === 'number' ? body.turn : undefined,
       blockIndex: typeof body.blockIndex === 'number' ? body.blockIndex : undefined,
@@ -2341,6 +2450,9 @@ export function apply(ctx, config) {
     carrier: config && config.carrier === 'user/message' ? 'user/message' : 'system/message',
     confirm: config && typeof config.confirm === 'boolean' ? config.confirm : false,
     replyMode: config && (config.replyMode === 'replay' || config.replyMode === 'patch') ? config.replyMode : 'auto',
+    editorStyle: config && (config.editorStyle === 'bubble' || config.editorStyle === 'center')
+      ? config.editorStyle
+      : 'frame',
   }
 
   // The in-place reply path needs two host seams: a plugin record with the

package/lib/patch.js

@@ -35,9 +35,27 @@ const KIND_TO_TYPES = {
  * @returns 'text' | 'reasoning' | null.
  */
 export function kindOfBlock(block) {
+  return blockField(block) === null ? null : blockField(block).kind
+}
+
+/**
+ * The editable text of one block, plus which field carries it.
+ *
+ * A platform is free to name the reasoning payload `text`, `reasoning` or
+ * `thinking`; the editor reads all three and writes back to the field it read,
+ * so a shape this build has not seen before is still editable.
+ *
+ * @param block - one content block.
+ * @returns `{ kind, field, text }`, or null when the block carries no text.
+ */
+export function blockField(block) {
   if (!block || typeof block !== 'object') return null
-  if (block.type === 'text' && typeof block.text === 'string') return 'text'
-  if ((block.type === 'reasoning' || block.type === 'thinking') && typeof block.text === 'string') return 'reasoning'
+  if (block.type === 'text' && typeof block.text === 'string') return { kind: 'text', field: 'text', text: block.text }
+  if (block.type === 'reasoning' || block.type === 'thinking') {
+    for (const field of ['text', 'reasoning', 'thinking']) {
+      if (typeof block[field] === 'string') return { kind: 'reasoning', field, text: block[field] }
+    }
+  }
   return null
 }
 
@@ -51,9 +69,9 @@ export function editableBlocks(message) {
   const out = []
   for (let index = 0; index < content.length; index += 1) {
     const block = content[index]
-    const kind = kindOfBlock(block)
-    if (kind === null) continue
-    out.push({ index, kind, text: block.text })
+    const found = blockField(block)
+    if (found === null) continue
+    out.push({ index, kind: found.kind, text: found.text })
   }
   return out
 }
@@ -125,10 +143,10 @@ export function applyTargetsToMessage(message, targets) {
   const content = Array.isArray(message.content) ? message.content.slice() : []
   for (const target of targets) {
     const block = content[target.blockIndex]
-    const kind = kindOfBlock(block)
-    if (kind === null || kind !== target.kind) continue
-    const patched = { ...block, text: target.text }
-    if (kind === 'reasoning') {
+    const found = blockField(block)
+    if (found === null || found.kind !== target.kind) continue
+    const patched = { ...block, [found.field]: target.text }
+    if (found.kind === 'reasoning') {
       // The signature signs the original text; keep it and some providers
       // reject the whole request. The recorded block keeps its signature; the
       // projected copy drops it, exactly like the disk path does.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-edit-turn",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "description": "Edit any message in DeepSeek Harness in place: a prompt is replaced where it stands; a model reply block (answer text or reasoning) is patched through a plugin record and a message projection, so the turn stays where it is, later turns are untouched and the log grows by one small record. Falls back to the replay splice on hosts without the projection API. The append-only session log is never rewritten.",
   "type": "module",
   "main": "lib/index.js",