@co0ontty/wand 1.61.0 → 1.62.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "676ee8ed1518463d31f33f9d6679d7700aac3eb7",
-  "builtAt": "2026-06-13T13:58:28.141Z",
-  "version": "1.61.0",
+  "commit": "33bc822b420b2e9276b9dbb72d9831452338b632",
+  "builtAt": "2026-06-14T01:57:11.796Z",
+  "version": "1.62.0",
   "channel": "stable"
 }

package/dist/server-session-routes.js

@@ -252,7 +252,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
         }
     });
     // ── Structured queued-messages management ──
-    // 三个端点构成"排队消息条"的后端操作面：reorder（拖拽换序）、单条删除、全部清空。
+    // 这些端点构成"排队消息条"的后端操作面：reorder、立即发送、单条删除、全部清空。
     // 全部走乐观更新模型，失败时前端会回滚到上一次 WS 推送的 queuedMessages。
     app.patch("/api/structured-sessions/:id/queued", express.json(), (req, res) => {
         const rawOrder = req.body?.order;
@@ -282,6 +282,27 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             res.status(400).json({ error: getErrorMessage(error, "无法删除排队消息。") });
         }
     });
+    app.post("/api/structured-sessions/:id/queued/:index/promote", express.json(), async (req, res) => {
+        const index = Number(req.params.index);
+        if (!Number.isInteger(index)) {
+            res.status(400).json({ error: "下标无效。" });
+            return;
+        }
+        const expectedText = typeof req.body?.expectedText === "string" ? req.body.expectedText : undefined;
+        const idempotencyKey = typeof req.body?.idempotencyKey === "string" ? req.body.idempotencyKey : undefined;
+        try {
+            const snapshot = await structured.promoteQueuedMessage(req.params.id, index, expectedText, idempotencyKey);
+            res.json(snapshot);
+        }
+        catch (error) {
+            const errorCode = error?.code;
+            const status = errorCode === "duplicate_idempotency_key" ? 409 : 400;
+            res.status(status).json({
+                error: getErrorMessage(error, "无法立即发送排队消息。"),
+                errorCode,
+            });
+        }
+    });
     app.delete("/api/structured-sessions/:id/queued", (req, res) => {
         try {
             const snapshot = structured.clearQueuedMessages(req.params.id);

package/dist/structured-session-manager.d.ts

@@ -90,6 +90,7 @@ export declare class StructuredSessionManager {
         interrupt?: boolean;
         idempotencyKey?: string;
         preserveQueue?: boolean;
+        queueAlreadyRemoved?: boolean;
     }): Promise<SessionSnapshot>;
     /**
      * Reorder the pending queued messages. `order` is a permutation of the current
@@ -102,6 +103,12 @@ export declare class StructuredSessionManager {
     reorderQueuedMessages(sessionId: string, order: number[]): SessionSnapshot;
     /** Remove a single queued message by index. */
     deleteQueuedMessage(sessionId: string, index: number): SessionSnapshot;
+    /**
+     * Remove one queued message by index before sending it. Keeping this operation
+     * on the server prevents clients from re-sending the text while the original
+     * queue entry remains available for the automatic flush path.
+     */
+    promoteQueuedMessage(sessionId: string, index: number, expectedText?: string, idempotencyKey?: string): Promise<SessionSnapshot>;
     /** Clear all queued messages. No-op when queue is already empty. */
     clearQueuedMessages(sessionId: string): SessionSnapshot;
     /** Update the selected model for a structured session. Takes effect on the next spawn. */

package/dist/structured-session-manager.js

@@ -632,17 +632,18 @@ export class StructuredSessionManager {
                     // 「立即发送」排队条某一条：interrupt 把它作为新输入重发，但该条仍留在
                     // queuedMessages 里。必须在这里把它从队列摘掉一次，否则 preserveQueue 会
                     // 原样保留整条队列，待 interruptPrompt 跑完 flushNextQueuedMessage 会把它
-                    // 当成普通排队再发一遍（重复发送）。客户端按 index 乐观删除，服务端这里
-                    // 没有 index，只能按文本删第一处匹配（排队文本入队时已 trim，promote 重发
-                    // 也会 trim，所以精确匹配可靠；重复文本极少见且语义等价）。
-                    const queue = session.queuedMessages ?? [];
-                    const removeAt = queue.indexOf(prompt);
-                    if (removeAt !== -1) {
-                        const trimmedQueue = queue.slice(0, removeAt).concat(queue.slice(removeAt + 1));
-                        session = { ...session, queuedMessages: trimmedQueue };
-                        this.sessions.set(id, session);
-                        this.storage.saveSession(session);
-                        this.emitStructuredSnapshot(session);
+                    // 当成普通排队再发一遍（重复发送）。旧客户端没有走 promote endpoint，
+                    // 服务端只能按文本删第一处匹配；新客户端会带 queueAlreadyRemoved 跳过这里。
+                    if (!opts.queueAlreadyRemoved) {
+                        const queue = session.queuedMessages ?? [];
+                        const removeAt = queue.indexOf(prompt);
+                        if (removeAt !== -1) {
+                            const trimmedQueue = queue.slice(0, removeAt).concat(queue.slice(removeAt + 1));
+                            session = { ...session, queuedMessages: trimmedQueue };
+                            this.sessions.set(id, session);
+                            this.storage.saveSession(session);
+                            this.emitStructuredSnapshot(session);
+                        }
                     }
                 }
                 else {
@@ -811,6 +812,44 @@ export class StructuredSessionManager {
         this.emitStructuredSnapshot(updated);
         return updated;
     }
+    /**
+     * Remove one queued message by index before sending it. Keeping this operation
+     * on the server prevents clients from re-sending the text while the original
+     * queue entry remains available for the automatic flush path.
+     */
+    async promoteQueuedMessage(sessionId, index, expectedText, idempotencyKey) {
+        const session = this.requireSession(sessionId);
+        if (idempotencyKey && this.seenIdempotencyKeys.has(`${sessionId}:${idempotencyKey}`)) {
+            return session;
+        }
+        const queue = session.queuedMessages ?? [];
+        if (!Number.isInteger(index) || index < 0 || index >= queue.length) {
+            throw new Error("队列中没有该条消息（可能已被处理）。");
+        }
+        if (expectedText !== undefined && queue[index] !== expectedText) {
+            throw new Error("排队消息已变化，请按最新顺序重试。");
+        }
+        const prompt = queue[index];
+        const remaining = queue.slice(0, index).concat(queue.slice(index + 1));
+        const inFlight = session.status === "running" && session.structuredState?.inFlight === true;
+        const updated = { ...session, queuedMessages: remaining };
+        this.sessions.set(sessionId, updated);
+        this.storage.saveSession(updated);
+        this.emitStructuredSnapshot(updated);
+        try {
+            return await this.sendMessage(sessionId, prompt, {
+                interrupt: inFlight,
+                preserveQueue: inFlight,
+                queueAlreadyRemoved: true,
+                idempotencyKey,
+            });
+        }
+        catch {
+            // Once the item has been promoted it must not return to the queue: the
+            // send path may have already persisted its user turn before a runner error.
+            return this.requireSession(sessionId);
+        }
+    }
     /** Clear all queued messages. No-op when queue is already empty. */
     clearQueuedMessages(sessionId) {
         const session = this.requireSession(sessionId);
@@ -1505,39 +1544,89 @@ export class StructuredSessionManager {
                 // 二条事件里的 tool_use 直接被丢掉——表现是 Agent / Read 等 tool_use 永远
                 // 不出现在 messages 里，subagent 多角色无法关联 agentType 到父 Task。
                 //
-                // 新规则：当类型不一致时，把新 block **追加**到 merged 末尾而非覆盖 prev。
-                // 既兼容 a)（同位置同类型仍按累积取大），又兼容 b)（拼接的新类型 block
-                // 进入末尾），还能挡住 b 早期版本里"短回退"的异常 frame（blocks.length
-                // < prev.length 时直接拒绝）。
-                if (blocks.length < prev.length)
-                    return;
-                const merged = [];
-                const appendix = [];
-                for (let i = 0; i < blocks.length; i++) {
-                    const a = prev[i];
-                    const b = blocks[i];
-                    if (a && !b) {
-                        merged.push(a);
-                        continue;
+                // 先判定 incoming 是不是 prev 的"累积超集"（mode a）：长度不短于 prev，
+                // 且前 prev.length 个 block 类型逐位一致。是 → 走逐位取大 + 末尾追加。
+                let cumulative = blocks.length >= prev.length;
+                if (cumulative) {
+                    for (let i = 0; i < prev.length; i++) {
+                        const a = prev[i];
+                        const b = blocks[i];
+                        if (a && b && a.type !== b.type) {
+                            cumulative = false;
+                            break;
+                        }
                     }
-                    if (!a && b) {
-                        merged.push(b);
-                        continue;
+                }
+                if (cumulative) {
+                    const merged = [];
+                    const appendix = [];
+                    for (let i = 0; i < blocks.length; i++) {
+                        const a = prev[i];
+                        const b = blocks[i];
+                        if (a && !b) {
+                            merged.push(a);
+                            continue;
+                        }
+                        if (!a && b) {
+                            merged.push(b);
+                            continue;
+                        }
+                        if (a && b) {
+                            if (a.type === b.type) {
+                                // 同类型：取信息量大者，避免短回退覆盖已经累积的内容。
+                                merged.push(blockVolume(b) >= blockVolume(a) ? b : a);
+                            }
+                            else {
+                                // 类型变了：保留 prev[i]，把 incoming block 追加到末尾。
+                                merged.push(a);
+                                appendix.push(b);
+                            }
+                        }
                     }
-                    if (a && b) {
-                        if (a.type === b.type) {
-                            // 同类型：取信息量大者，避免短回退覆盖已经累积的内容。
-                            merged.push(blockVolume(b) >= blockVolume(a) ? b : a);
+                    for (const b of appendix)
+                        merged.push(b);
+                    blocksByKey.set(key, merged);
+                    return;
+                }
+                // mode b（拼接/splice）：incoming 不是累积超集——SDK 把同一 msg.id 的
+                // thinking / text / 多个 tool_use 拆成一条条「只带新 block」的事件发出
+                // （新版 claude 连发 4 个 TaskCreate 就是这样）。老逻辑 `blocks.length <
+                // prev.length 直接 return` 会把这些单 block 事件整段丢弃，导致 TaskCreate /
+                // Agent / Read 等永远进不了 messages。这里保留 prev 全部，按 block 身份
+                // 增量合并：tool_use 用 id 去重（已存在则取信息量大的就地更新，否则追加）；
+                // text / thinking 仅在没有完全相同内容时追加，挡住「短回退」的重复 frame。
+                const merged = [...prev];
+                const idIndex = new Map();
+                merged.forEach((b, i) => {
+                    const anyB = b;
+                    if (b.type === "tool_use" && typeof anyB.id === "string")
+                        idIndex.set(anyB.id, i);
+                });
+                for (const b of blocks) {
+                    const anyB = b;
+                    if (b.type === "tool_use" && typeof anyB.id === "string") {
+                        const at = idIndex.get(anyB.id);
+                        if (at !== undefined) {
+                            if (blockVolume(b) >= blockVolume(merged[at]))
+                                merged[at] = b;
                         }
                         else {
-                            // 类型变了：保留 prev[i]，把 incoming block 追加到末尾。
-                            merged.push(a);
-                            appendix.push(b);
+                            idIndex.set(anyB.id, merged.length);
+                            merged.push(b);
                         }
+                        continue;
                     }
+                    if (b.type === "tool_result") {
+                        merged.push(b);
+                        continue;
+                    }
+                    // text / thinking：同类型且文本完全一致视为重复回退，跳过。
+                    const dup = merged.some((x) => x.type === b.type
+                        && x.text === anyB.text
+                        && x.thinking === anyB.thinking);
+                    if (!dup)
+                        merged.push(b);
                 }
-                for (const b of appendix)
-                    merged.push(b);
                 blocksByKey.set(key, merged);
             };
             const rebuildTurnBlocks = () => {