@qwen-code/channel-base 0.21.1 → 0.21.2

package/dist/ChannelBase.js

@@ -1,4 +1,5 @@
 import { basename, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
 import { BlockStreamer } from './BlockStreamer.js';
 import { ChannelProactiveDeliveryError, isChannelProactiveDeliveryError, } from './ChannelProactiveDeliveryError.js';
 import { GroupGate } from './GroupGate.js';
@@ -62,6 +63,9 @@ const SENSITIVE_PAYLOAD_KEY_PATTERN = new RegExp([
     'senderNick',
     'senderName',
 ].join('|'), 'i');
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
 /**
  * Character class (sans the enclosing `[]`) for a slash-command token: alphanumerics
  * plus `_`, `:` and `-`, so hyphenated and namespaced agent commands (e.g.
@@ -212,6 +216,7 @@ export class ChannelBase {
             sessionId: event.sessionId,
             target,
             request: event.request,
+            settlementListeners: new Set(),
         };
         this.pendingPermissions.set(event.requestId, pending);
         const chatKey = this.permissionChatKey(target);
@@ -219,6 +224,10 @@ export class ChannelBase {
         requestIds.push(event.requestId);
         this.pendingPermissionsByChat.set(chatKey, requestIds);
         try {
+            const presentation = this.tryPresentUserInput(pending);
+            if (presentation && (await presentation)) {
+                return;
+            }
             const text = this.formatPermissionRequest(pending);
             if (target.threadId !== undefined &&
                 this.supportsProactiveSend() &&
@@ -230,7 +239,7 @@ export class ChannelBase {
             }
         }
         catch (err) {
-            this.removePendingPermission(event.requestId);
+            this.removePendingPermission(event.requestId, 'cancelled');
             try {
                 await this.bridge.respondToPermission?.(event.requestId, {
                     outcome: { outcome: 'cancelled' },
@@ -242,6 +251,154 @@ export class ChannelBase {
             throw err;
         }
     }
+    tryPresentUserInput(pending) {
+        const active = this.activePrompts.get(pending.sessionId);
+        const questions = this.normalizeUserQuestions(pending);
+        const submitOptionId = this.approvalOptionId(pending);
+        if (!active ||
+            active.loopPrompt ||
+            !active.owner ||
+            !questions ||
+            !submitOptionId) {
+            return undefined;
+        }
+        const precedingSegment = this.closeOutputSegment(pending.sessionId, active, pending.target);
+        let respondInvoked = false;
+        const context = {
+            requestId: pending.requestId,
+            sessionId: pending.sessionId,
+            runId: active.runId,
+            owner: active.owner,
+            target: pending.target,
+            ...(precedingSegment
+                ? { precedingSegmentId: precedingSegment.segmentId }
+                : {}),
+            questions,
+            submitOptionId,
+            onSettled: (listener) => {
+                if (pending.settled) {
+                    listener(pending.settled);
+                    return () => { };
+                }
+                pending.settlementListeners.add(listener);
+                return () => {
+                    pending.settlementListeners.delete(listener);
+                };
+            },
+            respond: (response) => {
+                respondInvoked = true;
+                return this.respondToUserInput(pending, response);
+            },
+        };
+        pending.userInputPresented = true;
+        return (async () => {
+            try {
+                if (precedingSegment) {
+                    await this.notifyOutputSegmentEnd(pending.target.chatId, pending.sessionId, precedingSegment, 'input_requested');
+                }
+                const result = await this.presentUserInputRequest(context);
+                if (this.pendingPermissions.get(pending.requestId) !== pending) {
+                    return true;
+                }
+                if (result.kind === 'presented' ||
+                    (result.kind === 'handled' && respondInvoked)) {
+                    return true;
+                }
+                pending.userInputPresented = false;
+                return false;
+            }
+            catch (err) {
+                process.stderr.write(`[${this.name}] user input presentation failed for request ${sanitizeLogText(pending.requestId, 128)}: ${this.lifecycleError(err)}\n`);
+                if (this.pendingPermissions.get(pending.requestId) !== pending) {
+                    return true;
+                }
+                pending.userInputPresented = false;
+                return false;
+            }
+        })();
+    }
+    normalizeUserQuestions(pending) {
+        const toolCall = pending.request.toolCall;
+        const meta = isRecord(toolCall['_meta']) ? toolCall['_meta'] : undefined;
+        const canonical = meta?.['qwenInteractionKind'] === 'user_question';
+        const identifiedLegacy = meta?.['toolName'] === 'ask_user_question' ||
+            toolCall['kind'] === 'ask_user_question';
+        const rawInput = isRecord(toolCall['rawInput'])
+            ? toolCall['rawInput']
+            : undefined;
+        const rawQuestions = canonical
+            ? meta?.['qwenQuestions']
+            : identifiedLegacy
+                ? rawInput?.['questions']
+                : undefined;
+        if (!Array.isArray(rawQuestions) ||
+            rawQuestions.length < 1 ||
+            rawQuestions.length > 4) {
+            return undefined;
+        }
+        const questions = [];
+        for (const [index, rawQuestion] of rawQuestions.entries()) {
+            if (!isRecord(rawQuestion)) {
+                return undefined;
+            }
+            const header = rawQuestion['header'];
+            const question = rawQuestion['question'];
+            const rawOptions = rawQuestion['options'];
+            const multiSelect = rawQuestion['multiSelect'];
+            if (typeof header !== 'string' ||
+                header.trim().length === 0 ||
+                typeof question !== 'string' ||
+                question.trim().length === 0 ||
+                !Array.isArray(rawOptions) ||
+                rawOptions.length < 2 ||
+                rawOptions.length > 4 ||
+                (multiSelect !== undefined && typeof multiSelect !== 'boolean')) {
+                return undefined;
+            }
+            const options = [];
+            for (const rawOption of rawOptions) {
+                if (!isRecord(rawOption) ||
+                    typeof rawOption['label'] !== 'string' ||
+                    rawOption['label'].trim().length === 0 ||
+                    typeof rawOption['description'] !== 'string') {
+                    return undefined;
+                }
+                options.push({
+                    label: rawOption['label'],
+                    description: rawOption['description'],
+                });
+            }
+            questions.push({
+                answerKey: String(index),
+                header,
+                question,
+                options,
+                multiSelect: multiSelect ?? false,
+            });
+        }
+        return questions;
+    }
+    async respondToUserInput(pending, response) {
+        if (pending.responsePromise) {
+            return pending.responsePromise;
+        }
+        if (this.pendingPermissions.get(pending.requestId) !== pending ||
+            !this.bridge.respondToPermission) {
+            return false;
+        }
+        pending.responsePromise = Promise.resolve()
+            .then(() => this.bridge.respondToPermission(pending.requestId, response))
+            .then((accepted) => {
+            this.removePendingPermission(pending.requestId, accepted
+                ? this.userInputSettlementReason(pending, response.outcome)
+                : 'cancelled');
+            return accepted;
+        }, (error) => {
+            this.removePendingPermission(pending.requestId, 'cancelled');
+            throw error;
+        });
+        return pending.responsePromise;
+    }
     permissionTargetForEvent(event) {
         const routeTarget = this.router.getTarget(event.sessionId);
         if (!routeTarget || routeTarget.channelName !== this.name) {
@@ -268,7 +425,11 @@ export class ChannelBase {
         return target;
     }
     dispatchPermissionResolved(event) {
-        this.removePendingPermission(event.requestId);
+        const pending = this.pendingPermissions.get(event.requestId);
+        if (!pending) {
+            return;
+        }
+        this.removePendingPermission(event.requestId, this.userInputSettlementReason(pending, event.outcome));
     }
     constructor(name, config, bridge, options) {
         this.name = name;
@@ -322,6 +483,9 @@ export class ChannelBase {
      * logged, nothing more.
      */
     onTaskLifecycle(_event) { }
+    async presentUserInputRequest(_context) {
+        return { kind: 'unsupported' };
+    }
     emitTaskLifecycle(event) {
         try {
             const result = this.onTaskLifecycle(event);
@@ -351,6 +515,8 @@ export class ChannelBase {
             return;
         }
         active.cancellationEmitted = true;
+        const segment = this.closeOutputSegment(sessionId, active);
+        void this.notifyOutputSegmentEnd(active.chatId, sessionId, segment, 'cancelled');
         this.emitTaskLifecycle({
             ...this.lifecycleBase(active.chatId, sessionId, active.messageId),
             type: 'cancelled',
@@ -427,15 +593,72 @@ export class ChannelBase {
         return Boolean(this.config.identity || this.config.memoryScope);
     }
     lifecycleBase(chatId, sessionId, messageId) {
+        const active = this.activePrompts.get(sessionId);
         return {
             channelName: this.name,
             chatId,
             sessionId,
             ...(messageId ? { messageId } : {}),
+            ...(active?.runId ? { runId: active.runId } : {}),
+            ...(active?.owner ? { owner: active.owner } : {}),
             identity: this.identity,
             memoryScope: this.memoryScope,
         };
     }
+    outputSegmentContext(sessionId, active, segmentId, target) {
+        const resolvedTarget = target ??
+            (active.senderId
+                ? {
+                    channelName: this.name,
+                    chatId: active.chatId,
+                    senderId: active.senderId,
+                    ...(active.threadId ? { threadId: active.threadId } : {}),
+                    ...(active.isGroup !== undefined
+                        ? { isGroup: active.isGroup }
+                        : {}),
+                }
+                : undefined);
+        if (!active.owner ||
+            !resolvedTarget ||
+            resolvedTarget.channelName !== this.name) {
+            return undefined;
+        }
+        return {
+            channelName: this.name,
+            sessionId,
+            runId: active.runId,
+            segmentId,
+            owner: active.owner,
+            target: resolvedTarget,
+            ...(active.messageId ? { messageId: active.messageId } : {}),
+        };
+    }
+    ensureOutputSegment(sessionId, active) {
+        if (!active.owner)
+            return undefined;
+        const segmentId = active.activeSegmentId ?? randomUUID();
+        const context = this.outputSegmentContext(sessionId, active, segmentId);
+        if (context)
+            active.activeSegmentId = segmentId;
+        return context;
+    }
+    closeOutputSegment(sessionId, active, target) {
+        const segmentId = active.activeSegmentId;
+        if (!segmentId)
+            return undefined;
+        active.activeSegmentId = undefined;
+        return this.outputSegmentContext(sessionId, active, segmentId, target);
+    }
+    async notifyOutputSegmentEnd(chatId, sessionId, segment, reason) {
+        if (!segment)
+            return;
+        try {
+            await this.onOutputSegmentEnd(chatId, sessionId, segment, reason);
+        }
+        catch (err) {
+            process.stderr.write(`[${this.name}] output segment boundary failed for session ${sanitizeLogText(sessionId, 64)}: ${this.lifecycleError(err)}\n`);
+        }
+    }
     supportsProactiveSend() {
         return false;
     }
@@ -751,6 +974,7 @@ export class ChannelBase {
                 doneResolve = resolve;
             });
             const promptState = {
+                runId: randomUUID(),
                 cancelled: false,
                 done,
                 resolve: doneResolve,
@@ -989,6 +1213,7 @@ export class ChannelBase {
                 doneResolve = resolve;
             });
             const promptState = {
+                runId: randomUUID(),
                 cancelled: false,
                 done,
                 resolve: doneResolve,
@@ -1212,10 +1437,18 @@ export class ChannelBase {
             active.cancelled = true;
             this.stopActiveStreaming(active, sessionId, reason);
             this.dropCollectBuffer(sessionId);
+            this.removePendingPermissionsForSession(sessionId, 'run_cancelled');
             this.emitTaskCancellation(active, sessionId, reason);
             return true;
         });
     }
+    requestPromptRunCancellation(sessionId, runId, reason = 'cancel_command') {
+        const active = this.activePrompts.get(sessionId);
+        if (!active || active.runId !== runId) {
+            return Promise.resolve(false);
+        }
+        return this.requestActivePromptCancellation(sessionId, reason);
+    }
     dropCollectBuffer(sessionId) {
         const buffer = this.collectBuffers.get(sessionId);
         if (!buffer)
@@ -1310,7 +1543,12 @@ export class ChannelBase {
      * Override to implement progressive display (e.g., updating an AI card in-place).
      * Default: no-op (chunks are collected internally and delivered via onResponseComplete).
      */
-    onResponseChunk(_chatId, _chunk, _sessionId) { }
+    onResponseChunk(_chatId, _chunk, _sessionId, _segment) { }
+    onOutputSegmentEnd(chatId, sessionId, _segment, reason) {
+        if (reason === 'response_boundary') {
+            return this.onResponseBoundary(chatId, sessionId);
+        }
+    }
     /**
      * Called when the agent starts a new response segment for the same prompt.
      * Override to clear adapter-owned streaming buffers.
@@ -1322,12 +1560,33 @@ export class ChannelBase {
         const threadId = active?.threadId ?? target?.threadId;
         await this.sendThreadMessage(chatId, threadId, text);
     }
+    /**
+     * Adapter hook for delivery-only metadata. The response delivery path can read
+     * the active prompt while it exists; adapters must not retain its raw content.
+     */
+    getResponseMessageId(sessionId) {
+        return this.activePrompts.get(sessionId)?.messageId;
+    }
+    getResponseSenderId(sessionId) {
+        return this.activePrompts.get(sessionId)?.senderId;
+    }
+    getResponseMetadata(sessionId) {
+        return this.activePrompts.get(sessionId)?.metadata;
+    }
+    /**
+     * Returns the active prompt's response thread while it remains available for
+     * adapter delivery. Falls back to the session target after prompt cleanup.
+     */
+    getResponseThreadId(sessionId) {
+        return (this.activePrompts.get(sessionId)?.threadId ??
+            this.router.getTarget(sessionId)?.threadId);
+    }
     /**
      * Called when the agent's full response is ready.
      * Override to customize delivery (e.g., finalize an AI card).
      * Default: sends the full response text.
      */
-    async onResponseComplete(chatId, fullText, sessionId) {
+    async onResponseComplete(chatId, fullText, sessionId, _segment) {
         await this.sendResponseMessage(chatId, fullText, sessionId);
     }
     /**
@@ -1384,12 +1643,13 @@ export class ChannelBase {
         }
         return live;
     }
-    removePendingPermission(requestId) {
+    removePendingPermission(requestId, reason = 'resolved_outside_presenter') {
         const pending = this.pendingPermissions.get(requestId);
         if (!pending) {
             return;
         }
         this.pendingPermissions.delete(requestId);
+        this.settleUserInput(pending, reason);
         const chatKey = this.permissionChatKey(pending.target);
         const requestIds = this.pendingPermissionsByChat.get(chatKey);
         if (!requestIds) {
@@ -1403,17 +1663,48 @@ export class ChannelBase {
             this.pendingPermissionsByChat.set(chatKey, remaining);
         }
     }
-    removePendingPermissionsForSession(sessionId) {
+    removePendingPermissionsForSession(sessionId, reason = 'cancelled') {
         const requestIds = Array.from(this.pendingPermissions)
             .filter(([, pending]) => pending.sessionId === sessionId)
             .map(([requestId]) => requestId);
         for (const requestId of requestIds) {
-            this.removePendingPermission(requestId);
+            this.removePendingPermission(requestId, reason);
         }
     }
     clearPendingPermissions() {
-        this.pendingPermissions.clear();
-        this.pendingPermissionsByChat.clear();
+        for (const requestId of Array.from(this.pendingPermissions.keys())) {
+            this.removePendingPermission(requestId, 'cancelled');
+        }
+    }
+    settleUserInput(pending, reason) {
+        if (pending.settled) {
+            return;
+        }
+        pending.settled = reason;
+        const listeners = Array.from(pending.settlementListeners);
+        pending.settlementListeners.clear();
+        for (const listener of listeners) {
+            try {
+                listener(reason);
+            }
+            catch (err) {
+                process.stderr.write(`[${this.name}] user input settlement listener failed for request ${sanitizeLogText(pending.requestId, 128)}: ${this.lifecycleError(err)}\n`);
+            }
+        }
+    }
+    userInputSettlementReason(pending, outcome) {
+        if (outcome?.outcome === 'cancelled') {
+            return 'cancelled';
+        }
+        if (outcome?.outcome === 'selected') {
+            const selected = pending.request.options.find((option) => option.optionId === outcome.optionId);
+            if (selected?.kind === 'reject_once' ||
+                (selected?.optionId === 'cancel' &&
+                    selected.kind === undefined)) {
+                return 'cancelled';
+            }
+        }
+        return 'resolved_outside_presenter';
     }
     pendingPermissionForEnvelope(envelope, args) {
         const trimmed = args.trim();
@@ -1447,6 +1738,8 @@ export class ChannelBase {
     canEnvelopeAnswerPendingPermission(envelope, pending) {
         return (pending.target.chatId === envelope.chatId &&
             pending.target.threadId === envelope.threadId &&
+            (!pending.userInputPresented ||
+                pending.target.senderId === envelope.senderId) &&
             (this.isSharedSessionTarget(pending.target) ||
                 pending.target.senderId === envelope.senderId));
     }
@@ -1541,6 +1834,10 @@ export class ChannelBase {
             return true;
         }
         const { pending } = lookup;
+        if (pending.userInputPresented && decision !== 'deny') {
+            await this.sendMessage(envelope.chatId, 'Submit this question through its interactive card, or use /deny [request-id] to cancel it.');
+            return true;
+        }
         const response = (() => {
             if (decision === 'deny') {
                 return this.denialResponse(pending);
@@ -1560,7 +1857,9 @@ export class ChannelBase {
         }
         let accepted;
         try {
-            accepted = await this.bridge.respondToPermission(pending.requestId, response);
+            accepted = pending.userInputPresented
+                ? await this.respondToUserInput(pending, response)
+                : await this.bridge.respondToPermission(pending.requestId, response);
         }
         catch (err) {
             this.removePendingPermission(pending.requestId);
@@ -1597,7 +1896,7 @@ export class ChannelBase {
                     // already queued onto this session sees a stale generation and bails
                     // instead of running bridge.prompt() against the cleared session.
                     this.sessionGenerations.set(id, (this.sessionGenerations.get(id) ?? 0) + 1);
-                    this.removePendingPermissionsForSession(id);
+                    this.removePendingPermissionsForSession(id, 'run_cancelled');
                     // Cancel an in-flight turn (and drop its buffered follow-ups) before
                     // purging, so a running prompt can't deliver a stale response into —
                     // or resurrect via collect-drain — the just-cleared session.
@@ -3328,6 +3627,7 @@ export class ChannelBase {
                         // turn at the channel level (cancelled is already set above), so
                         // the event reflects that intent, not the bridge RPC outcome.
                         this.emitTaskCancellation(active, sessionId, 'steer');
+                        this.removePendingPermissionsForSession(sessionId, 'run_cancelled');
                     }
                     // Diagnostic watchdog: if the predecessor turn is STILL the active prompt
                     // after the wind-down bound, this steered turn is wedged behind a hung
@@ -3456,6 +3756,11 @@ export class ChannelBase {
                 doneResolve = r;
             });
             const promptState = {
+                runId: randomUUID(),
+                owner: {
+                    kind: 'channel_user',
+                    id: envelope.senderId,
+                },
                 cancelled: false,
                 done,
                 resolve: doneResolve,
@@ -3465,6 +3770,7 @@ export class ChannelBase {
                 messageId: envelope.messageId,
                 senderId: envelope.senderId,
                 senderName: envelope.senderName,
+                metadata: envelope.metadata,
             };
             // This turn is now the single owner of the session's active-prompt slot.
             // (Steer no longer hands a still-active session to a replacement; only
@@ -3499,12 +3805,13 @@ export class ChannelBase {
             const releaseHeldChunks = () => {
                 for (const held of heldChunks.splice(0)) {
                     hasStreamedText = true;
+                    const segment = this.ensureOutputSegment(sessionId, promptState);
                     this.emitTaskLifecycle({
                         ...this.lifecycleBase(envelope.chatId, sessionId, envelope.messageId),
                         type: 'text_chunk',
                         chunk: held,
                     });
-                    this.onResponseChunk(envelope.chatId, held, sessionId);
+                    this.onResponseChunk(envelope.chatId, held, sessionId, segment);
                     streamer?.push(held);
                 }
             };
@@ -3525,7 +3832,8 @@ export class ChannelBase {
                 }
                 heldChunks.length = 0;
                 hasStreamedText = false;
-                this.onResponseBoundary(envelope.chatId, sessionId);
+                const segment = this.closeOutputSegment(sessionId, promptState);
+                void this.notifyOutputSegmentEnd(envelope.chatId, sessionId, segment, 'response_boundary');
                 streamer?.stop();
             };
             const promptBridge = this.bridge;
@@ -3550,7 +3858,11 @@ export class ChannelBase {
                         await streamer.flush();
                     }
                     else {
-                        await this.onResponseComplete(envelope.chatId, response, sessionId);
+                        const segment = this.ensureOutputSegment(sessionId, promptState);
+                        await this.onResponseComplete(envelope.chatId, response, sessionId, segment);
+                        if (segment && promptState.activeSegmentId === segment.segmentId) {
+                            promptState.activeSegmentId = undefined;
+                        }
                     }
                 }
                 // Once delivery started the turn's outcome is fixed — don't let a
@@ -3559,6 +3871,8 @@ export class ChannelBase {
                     await this.settleCancelRequested(promptState);
                 }
                 if (!promptState.cancelled && !promptState.cancellationEmitted) {
+                    const segment = this.closeOutputSegment(sessionId, promptState);
+                    void this.notifyOutputSegmentEnd(envelope.chatId, sessionId, segment, 'completed');
                     this.emitTaskLifecycle({
                         ...this.lifecycleBase(envelope.chatId, sessionId, envelope.messageId),
                         type: 'completed',
@@ -3574,6 +3888,8 @@ export class ChannelBase {
                 }
                 if (!promptState.cancelled) {
                     releaseHeldChunks();
+                    const segment = this.closeOutputSegment(sessionId, promptState);
+                    void this.notifyOutputSegmentEnd(envelope.chatId, sessionId, segment, 'failed');
                     this.emitTaskLifecycle({
                         ...this.lifecycleBase(envelope.chatId, sessionId, envelope.messageId),
                         type: 'failed',
@@ -3587,6 +3903,9 @@ export class ChannelBase {
                     const safeMessageId = sanitizeLogText(envelope.messageId ?? '', 64);
                     process.stderr.write(`[${channel}] turn ${safeMessageId} threw after cancellation for session ${safeSessionId}: ${this.lifecycleError(err)}\n`);
                 }
+                if (promptState.cancelled) {
+                    return;
+                }
                 throw err;
             }
             finally {