dsh-edit-turn 0.3.3 → 0.5.2

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.3'
+export const PLUGIN_VERSION = '0.5.2'
 
 // 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
@@ -162,8 +162,20 @@ export const Config =
          * replay splice otherwise; `patch` refuses to run without the
          * projection; `replay` always uses the old path. Prompt edits always use
          * the official surface replacement.
+         *
+         * There is deliberately no `replace` value: appending a fresh
+         * `assistant/message` with a replace op is refused by the session's own
+         * surface validation (see the note in the README).
          */
         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 +1312,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 +1342,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 +1737,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 +1845,88 @@ 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')
+  // No busy gate here: this path only appends the in-place patch record, which
+  // leaves every surface node where it is. A running turn keeps writing its own
+  // events; the record lands between them and the fold ignores it.
+  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) {
+    const message = String((error && error.message) || error)
+    if (isProjectionUnavailable(message)) {
+      throw new HttpError(409, 'projection-missing', 'the edit-turn projection is not registered for this session; restart DSH so the owning plugin registers it, then retry')
+    }
+    throw new HttpError(409, 'stale', `the session refused the patch record: ${message}`)
+  }
+  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')
@@ -1820,20 +1937,23 @@ async function applyEdit(ctx, sessionId, body, config) {
   }
   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 busy = isBusy(events)
 
   const surfaceNodes = surfaceOf(ctx, sessionId, events)
   const patches = patchesOf(events)
   const patchMode = config.patch === true
+  const request = {
+    // 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,
+    kind: typeof body.kind === 'string' ? body.kind : undefined,
+  }
   let plan
   try {
-    plan = planRollback(events, surfaceNodes, {
-      seq: 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,
-      kind: typeof body.kind === 'string' ? body.kind : undefined,
-    }, { patches, patch: patchMode })
+    plan = planRollback(events, surfaceNodes, request, { patches, patch: patchMode })
   } catch (error) {
     if (error instanceof EditPlanError) {
       const status = error.code === 'not-editable' ? 400 : 409
@@ -1842,6 +1962,13 @@ async function applyEdit(ctx, sessionId, body, config) {
     throw error
   }
 
+  // A running turn is a hard stop for every path that moves the surface: the
+  // prompt rewrite shadows a message the turn may still be reading, and the
+  // replay splice shadows a window and regenerates the tail. The in-place record
+  // below moves nothing, so it is allowed to land while the agent is still
+  // writing - the model reads it on its next fold.
+  if (busy && plan.patch !== true) throw new HttpError(409, 'busy', 'the session is still working')
+
   // The in-place reply path: one small plugin record, interpreted by this
   // plugin's projection. Nothing leaves the surface, so there is no window to
   // check, no turn to open and no tail to replay. The record is append-only and
@@ -1871,8 +1998,19 @@ async function applyEdit(ctx, sessionId, body, config) {
         buildPatchData([{ 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 message = String((error && error.message) || error)
+      // The projection is not registered for this session (a live reload that
+      // dropped it). The same edit can land through the replay path, which
+      // needs no projection - so fall through instead of failing the save.
+      if (isProjectionUnavailable(message)) {
+        // The fallback replays the tail, which a running turn forbids.
+        if (busy) throw new HttpError(409, 'busy', 'the session is still working')
+        plan = planRollback(events, surfaceNodes, request, { patches, patch: false })
+      } else {
+        throw new HttpError(409, 'stale', `the session refused the patch record: ${message}`)
+      }
     }
+    if (plan.patch === true) {
     const flush = await flushSession(ctx, session)
     return {
       kind: 'reply',
@@ -1890,6 +2028,7 @@ async function applyEdit(ctx, sessionId, body, config) {
       shadowed: [],
       ...flush,
     }
+    }
   }
 
   // The live surface is the append authority; a node that vanished between the
@@ -2324,9 +2463,25 @@ function requireSessionId(value) {
   return value
 }
 
+/**
+ * Whether the host refused a plugin record because its projection is no longer
+ * registered for this session (a live reload that dropped it, or a session
+ * loaded before the owning plugin). Such a save can still go through the replay
+ * path, so it is not fatal.
+ *
+ * @param message - the host's error text.
+ * @returns true when the record's projection is gone.
+ */
+export function isProjectionUnavailable(message) {
+  return typeof message === 'string' && /projection .*was removed or replaced/i.test(message)
+}
+
 function failure(res, error) {
   const status = error instanceof HttpError ? error.status : 500
   const code = error instanceof HttpError ? error.code : 'internal'
+  // An unexpected throw is the only case the client cannot explain; leave the
+  // stack in the host log so a report can name the cause.
+  if (!(error instanceof HttpError)) console.error('[dsh-edit-turn] internal error', error)
   sendJson(res, status, { ok: false, code, error: String((error && error.message) || error) })
 }
 
@@ -2341,6 +2496,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.3",
+  "version": "0.5.2",
   "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",