@pimote/pimote 0.5.1 → 0.7.0

package/server/dist/voice/walk-back.js

@@ -92,45 +92,97 @@ function rewriteByToolCallId(messages, heardText, targetId) {
         // do is honour step 1 (already done).
         return messages;
     }
+    // Walkback is about what the user *heard* (speech), not about undoing the
+    // agent's real work. So we surgically prune only speak() calls from the
+    // target onward — truncate/drop the target, drop later speaks — and keep
+    // every other tool call (and its result) and other content intact. Results
+    // of pruned speaks are dropped too (a tool_result with no tool_use is the
+    // riskier dangling direction). `stopReason` is preserved, not synthesised:
+    // the target is no longer necessarily the last message.
+    const droppedSpeakIds = new Set();
     const targetMsg = messages[targetMsgIdx];
     const targetContent = contentOf(targetMsg);
     const targetBlock = targetContent[targetBlockIdx];
     const originalText = getSpeakText(targetBlock);
+    // Blocks before the target were spoken/heard earlier in the turn — keep.
     const newBlocks = targetContent.slice(0, targetBlockIdx);
-    const droppedToolUseIds = new Set();
     if (heardText.length === 0) {
-        // Nothing was heard of this speak. Drop the block and its paired
-        // tool_result (if any).
-        droppedToolUseIds.add(targetId);
+        droppedSpeakIds.add(targetId); // nothing heard — drop the speak + its result
     }
     else if (heardText.length >= originalText.length) {
-        // Entire utterance was heard. Keep block intact.
-        newBlocks.push(targetBlock);
+        newBlocks.push(targetBlock); // whole utterance heard — keep intact (+ its result)
     }
     else {
-        // Partial. Truncate text in-place and drop the paired tool_result
-        // (per the contract — a truncated speak's result is no longer
-        // grounded in what the user heard).
-        newBlocks.push(replaceSpeakText(targetBlock, heardText));
-        droppedToolUseIds.add(targetId);
+        newBlocks.push(replaceSpeakText(targetBlock, heardText)); // partial — truncate
+        droppedSpeakIds.add(targetId); // a truncated speak's result is no longer grounded
     }
-    // Anything in this message AFTER the target block was emitted after
-    // the heard prefix and so was not heard.
+    // Blocks after the target in the same message: drop later speaks, keep the rest.
     for (let j = targetBlockIdx + 1; j < targetContent.length; j++) {
-        const id = getToolCallId(targetContent[j]);
-        if (id)
-            droppedToolUseIds.add(id);
+        const block = targetContent[j];
+        if (isSpeakToolCall(block)) {
+            const id = getToolCallId(block);
+            if (id)
+                droppedSpeakIds.add(id);
+        }
+        else {
+            newBlocks.push(block);
+        }
+    }
+    const out = messages.slice(0, targetMsgIdx);
+    if (newBlocks.length > 0) {
+        out.push({ ...targetMsg, content: newBlocks });
+    }
+    // Subsequent messages: keep them, but drop speak tool calls (and the
+    // tool_results of any dropped speak). Forward iteration guarantees a speak's
+    // id is recorded before its (later) result message is examined.
+    for (let i = targetMsgIdx + 1; i < messages.length; i++) {
+        const kept = filterPrunedSpeaks(messages[i], droppedSpeakIds);
+        if (kept)
+            out.push(kept);
+    }
+    return out;
+}
+/**
+ * Drop pruned-speak content from a trailing message: removes speak tool calls
+ * (recording their ids) and the tool_results of any dropped speak, keeping all
+ * other content. Returns the (possibly rewritten) message, or null if it ends
+ * up empty.
+ */
+function filterPrunedSpeaks(msg, droppedSpeakIds) {
+    // pi's runtime shape: a tool result is its own message (role 'toolResult')
+    // referencing one toolCallId at the message level.
+    if (isToolResultMessage(msg)) {
+        const ref = toolResultMessageRefId(msg);
+        return ref && droppedSpeakIds.has(ref) ? null : msg;
+    }
+    const content = contentOf(msg);
+    if (content.length === 0)
+        return msg;
+    let changed = false;
+    const kept = [];
+    for (const block of content) {
+        if (isSpeakToolCall(block)) {
+            const id = getToolCallId(block);
+            if (id)
+                droppedSpeakIds.add(id);
+            changed = true;
+            continue;
+        }
+        // Block-level tool_result (Anthropic shape) for a dropped speak.
+        if (isToolResultBlock(block)) {
+            const ref = toolResultBlockRefId(block);
+            if (ref && droppedSpeakIds.has(ref)) {
+                changed = true;
+                continue;
+            }
+        }
+        kept.push(block);
     }
-    const rewrittenTarget = {
-        ...targetMsg,
-        content: newBlocks,
-        stopReason: 'aborted',
-    };
-    // Anything AFTER the target message in the array was emitted by the
-    // agent after the interrupted speak — drop it. This includes any
-    // tool_result messages whose paired speak we just truncated, plus
-    // any subsequent assistant messages.
-    return [...messages.slice(0, targetMsgIdx), rewrittenTarget];
+    if (!changed)
+        return msg;
+    if (kept.length === 0)
+        return null;
+    return { ...msg, content: kept };
 }
 // ---------------------------------------------------------------------------
 // Shape-tolerant accessors. pi-agent-core's runtime AgentMessage uses
@@ -165,6 +217,22 @@ function getToolCallId(block) {
     const id = block.id;
     return typeof id === 'string' ? id : undefined;
 }
+/** pi runtime tool-result message (role 'toolResult', message-level toolCallId). */
+function isToolResultMessage(msg) {
+    return msg.role === 'toolResult';
+}
+function toolResultMessageRefId(msg) {
+    const id = msg.toolCallId;
+    return typeof id === 'string' ? id : undefined;
+}
+/** Block-level tool result (Anthropic `tool_result` / pi `toolResult`). */
+function isToolResultBlock(block) {
+    return block.type === 'tool_result' || block.type === 'toolResult';
+}
+function toolResultBlockRefId(block) {
+    const ref = block.tool_use_id ?? block.toolCallId;
+    return typeof ref === 'string' ? ref : undefined;
+}
 function getSpeakText(block) {
     // Try both shapes; whichever holds a string wins.
     const args = block.arguments;

package/server/dist/voice-orchestrator-boot.js

@@ -35,15 +35,32 @@ export function buildVoiceOrchestrator(args) {
         config,
         sessionManager,
         busResolver,
-        displaceOwner: async (sessionId, _newOwner) => {
+        displaceOwner: async (sessionId, newOwner) => {
             const slot = sessionManager.getSlot(sessionId);
-            const existingClientId = slot?.connection?.connectedClientId;
-            if (!existingClientId)
+            if (!slot)
                 return;
-            const existing = clientRegistry.get(existingClientId);
-            existing?.sendDisplacedEvent(sessionId);
+            // Notify the displaced owner (if a different client), then transfer
+            // ownership to the new caller through the SAME claim path open_session
+            // uses — sets slot.connection, subscribes, rebinds extensions, replays
+            // pending UI. Without the claim, slot.connection stayed the displaced
+            // client: events streamed to a dead socket and idle-reap never fired.
+            const existingClientId = slot.connection?.connectedClientId;
+            if (existingClientId && existingClientId !== newOwner.connectedClientId) {
+                clientRegistry.get(existingClientId)?.sendDisplacedEvent(sessionId);
+            }
+            await clientRegistry.get(newOwner.connectedClientId)?.claimSession(sessionId, slot);
         },
         isOwnedByVoiceCall: (sessionId) => orchestrator.isCallActive(sessionId),
+        notifyCallEnded: (sessionId) => {
+            // The voice extension self-deactivated (speechmux WS failed/dropped).
+            // Tell the owning client so its VoiceCallStore tears down instead of
+            // waiting for WebRTC to time out. (review finding H4)
+            const slot = sessionManager.getSlot(sessionId);
+            const ownerClientId = slot?.connection?.connectedClientId;
+            if (!ownerClientId)
+                return;
+            clientRegistry.get(ownerClientId)?.sendCallEndedEvent(sessionId, 'error');
+        },
     });
     return {
         orchestrator,

package/server/dist/voice-orchestrator.js

@@ -17,13 +17,41 @@ export class CallBindError extends Error {
 export class VoiceOrchestrator {
     opts;
     activeCalls = new Set();
+    /** Per-session unsubscribe fns for the `pimote:voice:deactivate` bus
+     *  listener installed on bind (so the server learns of extension-initiated
+     *  deactivations — speechmux drop / open failure). */
+    deactivateUnsubs = new Map();
     constructor(opts) {
         this.opts = opts;
     }
     /** Drop all active-call bookkeeping. Idempotent. Called on server shutdown. */
     async stop() {
+        for (const unsub of this.deactivateUnsubs.values()) {
+            try {
+                unsub();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        this.deactivateUnsubs.clear();
         this.activeCalls.clear();
     }
+    /**
+     * Handle a `pimote:voice:deactivate` the voice extension emitted on its own
+     * (speechmux WS failed/dropped mid-call). Our own `endCall` removes the
+     * session from `activeCalls` *before* emitting deactivate, so the
+     * `activeCalls.has` guard distinguishes an extension-initiated deactivate
+     * from our own — preventing a feedback loop and a duplicate `call_ended`.
+     */
+    handleExtensionDeactivated(sessionId) {
+        if (!this.activeCalls.has(sessionId))
+            return;
+        this.activeCalls.delete(sessionId);
+        this.deactivateUnsubs.get(sessionId)?.();
+        this.deactivateUnsubs.delete(sessionId);
+        this.opts.notifyCallEnded?.(sessionId);
+    }
     /** Called by ws-handler for CallBindCommand. */
     async bindCall(args) {
         const slot = this.opts.busResolver.getSlot(args.sessionId);
@@ -49,13 +77,18 @@ export class VoiceOrchestrator {
         if (!bus) {
             throw new CallBindError('call_bind_failed_internal', 'Session has no EventBus');
         }
+        // Subscribe to extension-initiated deactivate BEFORE activating so a
+        // self-deactivate during/after activation is never missed. Replace any
+        // prior subscription for this session (force-rebind).
+        this.deactivateUnsubs.get(args.sessionId)?.();
+        this.deactivateUnsubs.set(args.sessionId, bus.on('pimote:voice:deactivate', () => this.handleExtensionDeactivated(args.sessionId)));
+        this.activeCalls.add(args.sessionId);
         const activate = {
             type: 'pimote:voice:activate',
             sessionId: args.sessionId,
             speechmuxWsUrl: llmWsUrl,
         };
         bus.emit(activate.type, activate);
-        this.activeCalls.add(args.sessionId);
         return {
             sessionId: args.sessionId,
             webrtcSignalUrl: signalUrl,
@@ -66,6 +99,10 @@ export class VoiceOrchestrator {
         if (!this.activeCalls.has(args.sessionId))
             return;
         this.activeCalls.delete(args.sessionId);
+        // Drop our deactivate subscription before emitting so our own emit can't
+        // loop back into handleExtensionDeactivated.
+        this.deactivateUnsubs.get(args.sessionId)?.();
+        this.deactivateUnsubs.delete(args.sessionId);
         const bus = this.opts.busResolver.getEventBus(args.sessionId);
         if (bus) {
             const deactivate = { type: 'pimote:voice:deactivate', sessionId: args.sessionId };