@qwen-code/channel-base 0.19.11-nightly.20260718.767a32484 → 0.19.11

package/README.md

@@ -72,9 +72,9 @@ Migration note for existing TypeScript plugins: if your adapter constructor or f
 Channel adapters can run in two host modes:
 
 - `qwen channel start [name]` is the standalone service. It uses `AcpBridge` over a `qwen-code --acp` child process and remains the default channel command.
-- `qwen serve --channel <name>` and `qwen serve --channel all` are experimental daemon-managed modes. Named channels are grouped by owning workspace and `qwen serve` starts one out-of-process worker per owning runtime. Each worker connects back to the daemon through the SDK, and adapters receive a `DaemonChannelBridge`-backed `ChannelAgentBridge` facade. `--channel all` stays primary-only.
+- `qwen serve --channel <name>` and `qwen serve --channel all` are experimental daemon-managed modes. `qwen serve` starts one out-of-process channel worker, the worker connects back to the daemon through the SDK, and adapters receive a `DaemonChannelBridge`-backed `ChannelAgentBridge` facade.
 
-In daemon-managed mode, every named channel's `cwd` must resolve to exactly one registered, trusted workspace. Its worker receives that runtime's cwd and environment overlay; an ambiguous or untrusted selection fails instead of using primary. The optional `shellCommand` method is exposed to adapters only when the daemon advertises the `session_shell_command` capability.
+In daemon-managed mode, one daemon is bound to one workspace. Every selected channel's `cwd` must resolve to that same workspace. The optional `shellCommand` method is exposed to adapters only when the daemon advertises the `session_shell_command` capability.
 
 ## Architecture
 

package/dist/ChannelAgentBridge.d.ts

@@ -62,13 +62,6 @@ export interface BridgeSessionInfo {
 }
 export interface ChannelAgentBridgeSessionOptions {
     approvalMode?: string;
-    /**
-     * Channel instance name (e.g. `feishu-main`) stamped as the daemon `sourceId`
-     * on **new** sessions — creation-time attribution paired with
-     * `sourceType: 'channel'`. Ignored by `loadSession`: loading an existing
-     * session never re-stamps its creation attribution.
-     */
-    sourceId?: string;
 }
 export interface ChannelAgentBridge {
     readonly availableCommands: AvailableCommand[];

package/dist/ChannelBase.d.ts

@@ -70,8 +70,7 @@ export declare abstract class ChannelBase {
      * so a cleared session can't be resurrected by an already-queued prompt.
      */
     private sessionGenerations;
-    private pendingChannelMemoryMutations;
-    private pendingChannelMemoryMutationDeliveries;
+    private pendingClears;
     /** Per-session active prompt tracking for dispatch modes. */
     private activePrompts;
     /** Per-session message buffer for collect mode. */
@@ -219,10 +218,8 @@ export declare abstract class ChannelBase {
     private renderChannelMemoryCandidates;
     private handleChannelMemoryIntent;
     private shouldClassifyChannelMemoryIntent;
-    private channelMemoryPendingKey;
-    private deliverPendingChannelMemoryMutation;
-    private takePendingChannelMemoryMutation;
-    private deletePendingChannelMemoryMutation;
+    private clearPendingKey;
+    private setPendingClear;
     private classifyChannelMemoryIntent;
     private channelMemoryErrorMessage;
     private channelMemoryUserErrorMessage;

package/dist/ChannelBase.js

@@ -110,8 +110,7 @@ export class ChannelBase {
      * so a cleared session can't be resurrected by an already-queued prompt.
      */
     sessionGenerations = new Map();
-    pendingChannelMemoryMutations = new Map();
-    pendingChannelMemoryMutationDeliveries = new Map();
+    pendingClears = new Map();
     /** Per-session active prompt tracking for dispatch modes. */
     activePrompts = new Map();
     /** Per-session message buffer for collect mode. */
@@ -1979,79 +1978,8 @@ export class ChannelBase {
             return;
         }
         if (intent.kind === 'clear_request') {
-            await this.deliverPendingChannelMemoryMutation(envelope, { kind: 'clear' }, 'This clears channel memory for this chat. Say "确认清空记忆" or "confirm clear memory" to proceed.');
-            return;
-        }
-        if (intent.kind === 'update_confirm' || intent.kind === 'remove_confirm') {
-            const pending = intent.kind === 'update_confirm'
-                ? this.takePendingChannelMemoryMutation(envelope, 'update')
-                : this.takePendingChannelMemoryMutation(envelope, 'remove');
-            if (!pending) {
-                await this.sendMessage(envelope.chatId, intent.kind === 'update_confirm'
-                    ? 'No pending channel memory update. Start a new update request first.'
-                    : 'No pending channel memory removal. Start a new removal request first.');
-                return;
-            }
-            const channelMemory = await this.getChannelMemory(envelope);
-            if (!channelMemory)
-                return;
-            const isUpdate = pending.kind === 'update';
-            let changed;
-            try {
-                if (isUpdate) {
-                    ({ changed } = await channelMemory.updateChannelMemoryEntry(this.channelMemoryTarget(envelope), {
-                        id: pending.id,
-                        text: pending.proposedText,
-                        expectedText: pending.expectedText,
-                    }));
-                }
-                else {
-                    ({ changed } = await channelMemory.removeChannelMemoryEntries(this.channelMemoryTarget(envelope), {
-                        ids: [pending.id],
-                        expectedTextById: { [pending.id]: pending.expectedText },
-                    }));
-                }
-            }
-            catch (error) {
-                const message = this.channelMemoryErrorMessage(error);
-                this.logChannelMemoryError(isUpdate ? 'update' : 'remove', envelope, message);
-                await this.sendMessage(envelope.chatId, message === 'Channel memory entry changed'
-                    ? 'That channel memory entry changed since it was selected. View channel memory and start the operation again.'
-                    : `Failed to ${isUpdate ? 'update' : 'remove'} channel memory: ${this.channelMemoryUserErrorMessage()}`);
-                return;
-            }
-            if (!changed) {
-                await this.sendMessage(envelope.chatId, `No channel memory entry ${pending.id}.`);
-                return;
-            }
-            this.invalidateSessionContext(envelope);
-            await this.sendMessage(envelope.chatId, `Channel memory ${pending.id} ${isUpdate ? 'updated' : 'removed'}.`);
-            return;
-        }
-        if (intent.kind === 'natural_update') {
-            await this.deliverPendingChannelMemoryMutation(envelope, {
-                kind: 'update',
-                id: intent.id,
-                expectedText: intent.expectedText,
-                proposedText: intent.text,
-            }, [
-                `Update channel memory ${intent.id}?`,
-                `Before: ${sanitizePromptText(intent.expectedText).trim()}`,
-                `After: ${sanitizePromptText(intent.text).trim()}`,
-                'Say "确认更新记忆" or "confirm memory update" within 60 seconds.',
-            ].join('\n'));
-            return;
-        }
-        if (intent.kind === 'natural_remove') {
-            await this.deliverPendingChannelMemoryMutation(envelope, {
-                kind: 'remove',
-                id: intent.id,
-                expectedText: intent.expectedText,
-            }, [
-                `Remove channel memory ${intent.id}?`,
-                sanitizePromptText(intent.expectedText).trim(),
-                'Say "确认删除记忆" or "confirm memory removal" within 60 seconds.',
-            ].join('\n'));
+            this.setPendingClear(this.clearPendingKey(envelope));
+            await this.sendMessage(envelope.chatId, 'This clears channel memory for this chat. Say "确认清空记忆" or "confirm clear memory" to proceed.');
             return;
         }
         const channelMemory = await this.getChannelMemory(envelope);
@@ -2061,7 +1989,7 @@ export class ChannelBase {
         if (intent.kind === 'remember') {
             let result;
             try {
-                result = await channelMemory.addChannelMemoryEntries(this.channelMemoryTarget(envelope), intent.texts, envelope.senderId);
+                result = await channelMemory.addChannelMemoryEntries(this.channelMemoryTarget(envelope), [intent.text], envelope.senderId);
             }
             catch (error) {
                 const message = this.channelMemoryErrorMessage(error);
@@ -2074,11 +2002,9 @@ export class ChannelBase {
             }
             if (result.added.length > 0) {
                 const ids = result.added.map((entry) => entry.id);
-                await this.sendMessage(envelope.chatId, result.duplicateIds.length > 0
-                    ? `Channel memory saved: ${ids.join(', ')}. Skipped duplicates: ${result.duplicateIds.join(', ')}.`
-                    : ids.length === 1
-                        ? `Channel memory ${ids[0]} saved.`
-                        : `Channel memory saved: ${ids.join(', ')}.`);
+                await this.sendMessage(envelope.chatId, ids.length === 1
+                    ? `Channel memory ${ids[0]} saved.`
+                    : `Channel memory saved: ${ids.join(', ')}.`);
             }
             else if (result.duplicateIds.length > 0) {
                 await this.sendMessage(envelope.chatId, `Channel memory already contains ${result.duplicateIds.join(', ')}.`);
@@ -2122,16 +2048,30 @@ export class ChannelBase {
             await this.sendMessage(envelope.chatId, [`Channel memory (page ${intent.page}/${totalPages}):`, ...lines].join('\n'));
             return;
         }
-        if (intent.kind === 'update' || intent.kind === 'remove') {
+        if (intent.kind === 'update' ||
+            intent.kind === 'remove' ||
+            intent.kind === 'natural_update' ||
+            intent.kind === 'natural_remove') {
             let changed;
-            const isUpdate = intent.kind === 'update';
+            const isUpdate = intent.kind === 'update' || intent.kind === 'natural_update';
             const id = intent.id;
             try {
                 if (isUpdate) {
-                    ({ changed } = await channelMemory.updateChannelMemoryEntry(this.channelMemoryTarget(envelope), { id: intent.id, text: intent.text }));
+                    ({ changed } = await channelMemory.updateChannelMemoryEntry(this.channelMemoryTarget(envelope), intent.kind === 'natural_update'
+                        ? {
+                            id: intent.id,
+                            text: intent.text,
+                            expectedText: intent.expectedText,
+                        }
+                        : { id: intent.id, text: intent.text }));
                 }
                 else {
-                    ({ changed } = await channelMemory.removeChannelMemoryEntries(this.channelMemoryTarget(envelope), { ids: [intent.id] }));
+                    ({ changed } = await channelMemory.removeChannelMemoryEntries(this.channelMemoryTarget(envelope), intent.kind === 'natural_remove'
+                        ? {
+                            ids: [intent.id],
+                            expectedTextById: { [intent.id]: intent.expectedText },
+                        }
+                        : { ids: [intent.id] }));
                 }
             }
             catch (error) {
@@ -2149,8 +2089,10 @@ export class ChannelBase {
             return;
         }
         if (intent.kind === 'clear_confirm') {
-            const pending = this.takePendingChannelMemoryMutation(envelope, 'clear');
-            if (!pending) {
+            const pendingKey = this.clearPendingKey(envelope);
+            const expiresAt = this.pendingClears.get(pendingKey);
+            this.pendingClears.delete(pendingKey);
+            if (expiresAt === undefined || expiresAt < Date.now()) {
                 await this.sendMessage(envelope.chatId, 'No pending clear request. Say "清空记忆" first.');
                 return;
             }
@@ -2180,62 +2122,17 @@ export class ChannelBase {
             !normalized.startsWith('/') &&
             CHANNEL_MEMORY_CLASSIFIER_TRIGGER_RE.test(normalized));
     }
-    channelMemoryPendingKey(envelope) {
-        return JSON.stringify([
-            this.name,
-            envelope.chatId,
-            envelope.threadId ?? null,
-            envelope.senderId ?? null,
-        ]);
+    clearPendingKey(envelope) {
+        return `${this.name}:${envelope.chatId}:${envelope.threadId ?? ''}:${envelope.senderId ?? ''}`;
     }
-    async deliverPendingChannelMemoryMutation(envelope, mutation, message) {
+    setPendingClear(key) {
         const now = Date.now();
-        for (const [pendingKey, pending] of this.pendingChannelMemoryMutations) {
-            if (pending.expiresAt < now) {
-                this.pendingChannelMemoryMutations.delete(pendingKey);
+        for (const [pendingKey, expiresAt] of this.pendingClears) {
+            if (expiresAt < now) {
+                this.pendingClears.delete(pendingKey);
             }
         }
-        this.deletePendingChannelMemoryMutation(envelope);
-        const key = this.channelMemoryPendingKey(envelope);
-        this.pendingChannelMemoryMutationDeliveries.set(key, mutation);
-        try {
-            await this.sendMessage(envelope.chatId, message);
-        }
-        catch (error) {
-            if (this.pendingChannelMemoryMutationDeliveries.get(key) === mutation) {
-                this.pendingChannelMemoryMutationDeliveries.delete(key);
-            }
-            throw error;
-        }
-        if (this.pendingChannelMemoryMutationDeliveries.get(key) !== mutation) {
-            return;
-        }
-        this.pendingChannelMemoryMutationDeliveries.delete(key);
-        this.pendingChannelMemoryMutations.set(key, {
-            ...mutation,
-            expiresAt: Date.now() + 60_000,
-        });
-    }
-    takePendingChannelMemoryMutation(envelope, kind) {
-        const key = this.channelMemoryPendingKey(envelope);
-        const pending = this.pendingChannelMemoryMutations.get(key);
-        if (!pending) {
-            return undefined;
-        }
-        if (pending.expiresAt < Date.now()) {
-            this.pendingChannelMemoryMutations.delete(key);
-            return undefined;
-        }
-        if (pending.kind !== kind) {
-            return undefined;
-        }
-        this.pendingChannelMemoryMutations.delete(key);
-        return pending;
-    }
-    deletePendingChannelMemoryMutation(envelope) {
-        const key = this.channelMemoryPendingKey(envelope);
-        this.pendingChannelMemoryMutations.delete(key);
-        this.pendingChannelMemoryMutationDeliveries.delete(key);
+        this.pendingClears.set(key, now + 60_000);
     }
     async classifyChannelMemoryIntent(envelope) {
         if (!this.memoryIntentClassifier || !this.channelMemory) {
@@ -2258,106 +2155,80 @@ export class ChannelBase {
             process.stderr.write(`[${this.name}] channel memory intent classifier failed: ${sanitizeLogText(this.channelMemoryErrorMessage(error), 200)}\n`);
             return null;
         }
-        try {
-            if (typeof classified !== 'object' || classified === null)
-                return null;
-            const result = classified;
-            const confidence = result.confidence;
-            if (typeof confidence !== 'number' ||
-                !Number.isFinite(confidence) ||
-                confidence < 0 ||
-                confidence > 1 ||
-                confidence < CHANNEL_MEMORY_CLASSIFIER_MIN_CONFIDENCE) {
-                return null;
-            }
-            const intent = result.intent;
-            if (intent === 'remember') {
-                const hasMemory = Object.prototype.hasOwnProperty.call(result, 'memory');
-                const hasMemories = Object.prototype.hasOwnProperty.call(result, 'memories');
-                if (hasMemory === hasMemories)
-                    return null;
-                let texts = [];
-                if (hasMemory) {
-                    const memory = result.memory;
-                    texts = typeof memory === 'string' ? [memory.trim()] : [];
-                }
-                else {
-                    const memories = result.memories;
-                    if (Array.isArray(memories)) {
-                        const snapshot = Array.from(memories);
-                        if (snapshot.every((memory) => typeof memory === 'string')) {
-                            texts = snapshot.map((memory) => memory.trim());
-                        }
-                    }
-                }
-                return texts.length >= 1 &&
-                    texts.length <= 10 &&
-                    texts.every((text) => text.length > 0)
-                    ? { kind: 'remember', texts }
-                    : null;
-            }
-            if (intent === 'clear_all')
-                return { kind: 'clear_request' };
-            if (intent !== 'list' &&
-                intent !== 'inspect' &&
-                intent !== 'update' &&
-                intent !== 'remove') {
-                return null;
-            }
-            const targetIds = result.targetIds;
-            if (intent === 'list' && targetIds === undefined) {
+        const confidence = classified && typeof classified === 'object'
+            ? classified.confidence
+            : undefined;
+        if (typeof confidence !== 'number' ||
+            !Number.isFinite(confidence) ||
+            confidence < 0 ||
+            confidence > 1 ||
+            confidence < CHANNEL_MEMORY_CLASSIFIER_MIN_CONFIDENCE) {
+            return null;
+        }
+        const result = classified;
+        const targetIds = result.targetIds;
+        const entryById = new Map(entries.map((entry) => [entry.id, entry]));
+        const resolvedEntries = targetIds === undefined
+            ? undefined
+            : Array.isArray(targetIds) &&
+                targetIds.every((id) => typeof id === 'string' && entryById.has(id)) &&
+                new Set(targetIds).size === targetIds.length
+                ? this.entriesForChannelMemoryIds(entries, targetIds)
+                : null;
+        if (result.intent === 'remember') {
+            const memory = typeof result.memory === 'string' ? result.memory.trim() : '';
+            return memory ? { kind: 'remember', text: memory } : null;
+        }
+        if (result.intent === 'list') {
+            if (resolvedEntries === undefined)
                 return { kind: 'list', page: 1 };
-            }
-            if (!Array.isArray(targetIds))
-                return null;
-            const targetIdSnapshot = Array.from(targetIds);
-            const entryById = new Map(entries.map((entry) => [entry.id, entry]));
-            if (!targetIdSnapshot.every((id) => typeof id === 'string' && entryById.has(id)) ||
-                new Set(targetIdSnapshot).size !== targetIdSnapshot.length) {
+            if (resolvedEntries === null)
                 return null;
-            }
-            const resolvedEntries = this.entriesForChannelMemoryIds(entries, targetIdSnapshot);
-            if (intent === 'list') {
-                return resolvedEntries.length === 0
-                    ? { kind: 'no_match' }
-                    : {
-                        kind: 'list_matches',
-                        ids: resolvedEntries.map((entry) => entry.id),
-                    };
-            }
-            if (resolvedEntries.length === 0)
-                return { kind: 'no_match' };
-            if (resolvedEntries.length > 1) {
-                return {
-                    kind: 'ambiguous',
+            return resolvedEntries.length === 0
+                ? { kind: 'no_match' }
+                : {
+                    kind: 'list_matches',
                     ids: resolvedEntries.map((entry) => entry.id),
                 };
-            }
-            const entry = resolvedEntries[0];
-            if (intent === 'inspect')
-                return { kind: 'inspect', id: entry.id };
-            if (intent === 'remove') {
-                return {
-                    kind: 'natural_remove',
-                    id: entry.id,
-                    expectedText: entry.text,
-                };
-            }
-            const memory = result.memory;
-            const text = typeof memory === 'string' ? memory.trim() : '';
-            return text
-                ? {
-                    kind: 'natural_update',
-                    id: entry.id,
-                    text,
-                    expectedText: entry.text,
-                }
-                : null;
         }
-        catch (error) {
-            process.stderr.write(`[${this.name}] channel memory intent validation failed: ${sanitizeLogText(this.channelMemoryErrorMessage(error), 200)}\n`);
+        if (result.intent === 'clear_all') {
+            return { kind: 'clear_request' };
+        }
+        if (result.intent !== 'inspect' &&
+            result.intent !== 'update' &&
+            result.intent !== 'remove') {
             return null;
         }
+        if (resolvedEntries === null || resolvedEntries === undefined)
+            return null;
+        if (resolvedEntries.length === 0)
+            return { kind: 'no_match' };
+        if (resolvedEntries.length > 1) {
+            return {
+                kind: 'ambiguous',
+                ids: resolvedEntries.map((entry) => entry.id),
+            };
+        }
+        const entry = resolvedEntries[0];
+        if (result.intent === 'inspect')
+            return { kind: 'inspect', id: entry.id };
+        if (result.intent === 'remove') {
+            return {
+                kind: 'natural_remove',
+                id: entry.id,
+                expectedText: entry.text,
+            };
+        }
+        const text = typeof result.memory === 'string' ? result.memory.trim() : '';
+        if (text) {
+            return {
+                kind: 'natural_update',
+                id: entry.id,
+                text,
+                expectedText: entry.text,
+            };
+        }
+        return null;
     }
     channelMemoryErrorMessage(error) {
         return error instanceof Error ? error.message : String(error);
@@ -2727,9 +2598,6 @@ export class ChannelBase {
             throw new Error('processInbound called without a successful preflightInbound check.');
         }
         let memoryIntent = parseChannelMemoryIntent(envelope.text);
-        if (memoryIntent?.kind === 'update' || memoryIntent?.kind === 'remove') {
-            this.deletePendingChannelMemoryMutation(envelope);
-        }
         if (!memoryIntent &&
             this.shouldClassifyChannelMemoryIntent(envelope.text)) {
             memoryIntent = await this.classifyChannelMemoryIntent(envelope);